public static ConcreteBuild BuildSource(Type pluggedType, ConstructorInfo constructor,
DependencyCollection dependencies, Policies policies)
{
ConcreteBuild plan = null;
try
{
var ctorStep = BuildConstructorStep(pluggedType, constructor, dependencies, policies);
plan = new ConcreteBuild(pluggedType, ctorStep);
determineSetterSources(pluggedType, dependencies, policies, plan);
}
catch (StructureMapException e)
{
e.Push("Attempting to create a build plan for concrete type " + pluggedType.GetFullName());
throw;
}
catch (Exception e)
{
throw new StructureMapConfigurationException(
"Attempting to create a build plan for concrete type " + pluggedType.GetFullName(), e);
}
return plan;
}
public void select_interceptors()
{
var activator1 = new ActivatorInterceptor<ITarget>(x => x.Activate());
var activator2 = new ActivatorInterceptor<Target>(x => x.UseSession(null));
var activator3 = new ActivatorInterceptor<Target>(x => x.ThrowUp());
var activator4 = new ActivatorInterceptor<ITarget>(x => x.Debug());
var activator5 = new ActivatorInterceptor<IGateway>(x => x.DoSomething());
var policies = new Policies();
policies.Add(activator1.ToPolicy());
policies.Add(activator2.ToPolicy());
policies.Add(activator3.ToPolicy());
policies.Add(activator4.ToPolicy());
policies.Add(activator5.ToPolicy());
var instance1 = new SmartInstance<Target>();
policies.Apply(typeof(ITarget), instance1);
instance1.Interceptors
.ShouldHaveTheSameElementsAs(activator1, activator2, activator3, activator4);
var instance2 = new SmartInstance<ATarget>();
policies.Apply(typeof(ITarget), instance2);
instance2.Interceptors
.ShouldHaveTheSameElementsAs(activator1, activator4);
var instance3 = new SmartInstance<StubbedGateway>();
policies.Apply(typeof(ITarget), instance3);
instance3.Interceptors
.ShouldHaveTheSameElementsAs(activator5);
}
public static BuildUpPlan BuildUpPlan(Type pluggedType, DependencyCollection dependencies, Policies policies)
{
var plan = new BuildUpPlan(pluggedType);
determineSetterSources(pluggedType, dependencies, policies, plan);
return plan;
}
public Expression ToExpression(Policies policies, ParameterExpression session, ParameterExpression variable)
{
var build = ToConcreteBuild(policies, variable);
var builder = build.ToExpression(session, Parameters.Context);
return Expression.Convert(builder, _pluginType);
}
public static ConstructorStep BuildConstructorStep(Type pluggedType, ConstructorInfo constructor,
DependencyCollection dependencies, Policies policies)
{
var ctor = constructor ?? policies.SelectConstructor(pluggedType);
if (ctor == null)
{
throw new StructureMapConfigurationException(
"No public constructor could be selected for concrete type " + pluggedType.GetFullName());
}
var ctorStep = new ConstructorStep(ctor);
var multiples = findTypesWithMultipleParametersRequired(ctor);
var ctorDependencies = ctor
.GetParameters()
.Select(x => {
var dependency = multiples.Contains(x.ParameterType)
? dependencies.FindByTypeAndName(x.ParameterType, x.Name)
: dependencies.FindByTypeOrName(x.ParameterType, x.Name);
if (dependency == null && ( (x.DefaultValue != null && x.DefaultValue.GetType().Name != "DBNull")))
{
dependency = x.DefaultValue;
}
return SourceFor(ConstructorArgument, x.Name, x.ParameterType, dependency);
});
ctorStep.Add(ctorDependencies);
return ctorStep;
}
private static void determineSetterSources(Type pluggedType, DependencyCollection dependencies,
Policies policies,
IHasSetters plan)
{
var setters = GetSetters(pluggedType);
setters.Each(setter => determineSetterSource(dependencies, policies, setter, plan));
}
public ConcreteBuild ToConcreteBuild(Policies policies, ParameterExpression variable)
{
variable = variable ?? Expression.Variable(_pluginType, "Inner");
var dependencies = _instance.Dependencies.Clone();
dependencies.Add(_pluginType, new LiteralDependencySource(variable, _pluginType));
var build = ConcreteType.BuildSource(_instance.PluggedType, _instance.Constructor, dependencies, policies);
return build;
}
internal Configuration(Policies policies,
ProtocolOptions protocolOptions,
PoolingOptions poolingOptions,
SocketOptions socketOptions,
ClientOptions clientOptions,
IAuthInfoProvider authProvider)
{
this._policies = policies;
this._protocolOptions = protocolOptions;
this._poolingOptions = poolingOptions;
this._socketOptions = socketOptions;
this._clientOptions = clientOptions;
this._authProvider = authProvider;
}
public BuildPlan(Type pluginType, Instance instance, IDependencySource inner, Policies policies,
IEnumerable<IInterceptor> interceptors)
{
_pluginType = pluginType;
_instance = instance;
_inner = inner;
if (interceptors.Any())
{
_interceptionPlan = new InterceptionPlan(pluginType, _inner, policies, interceptors);
}
var @delegate = ToDelegate();
_func = @delegate as Func<IBuildSession, IContext, object>;
}
public Configuration(Policies policies,
ProtocolOptions protocolOptions,
PoolingOptions poolingOptions,
SocketOptions socketOptions,
ClientOptions clientOptions,
IAuthInfoProvider authProvider,
bool metricsEnabled)
{
this._policies = policies;
this._protocolOptions = protocolOptions;
this._poolingOptions = poolingOptions;
this._socketOptions = socketOptions;
this._clientOptions = clientOptions;
this._authProvider = authProvider;
this._metricsEnabled = metricsEnabled;
}
public void do_not_duplicate_interceptor_policies()
{
var theActivator = new ActivatorInterceptor<ITarget>(x => x.Activate());
var policy1 = new InterceptorPolicy<ITarget>(theActivator);
var policy2 = new InterceptorPolicy<ITarget>(theActivator);
policy1.ShouldBe(policy2);
var policies = new Policies();
policies.Add(policy1);
policies.Add(policy2);
policies.Add(policy1);
policies.Add(policy2);
policies.Interception().Single().ShouldBeTheSameAs(policy1);
}
internal Configuration(Policies policies,
ProtocolOptions protocolOptions,
PoolingOptions poolingOptions,
SocketOptions socketOptions,
ClientOptions clientOptions,
IAuthProvider authProvider,
IAuthInfoProvider authInfoProvider,
QueryOptions queryOptions)
{
_policies = policies;
_protocolOptions = protocolOptions;
_poolingOptions = poolingOptions;
_socketOptions = socketOptions;
_clientOptions = clientOptions;
_authProvider = authProvider;
_authInfoProvider = authInfoProvider;
_queryOptions = queryOptions;
}
public void Validate(IPipelineGraph pipeline, Policies policies)
{
var report = new ProfileReport(pipeline);
_reports.Add(report);
var closedTypes = pipeline.ToModel().PluginTypes.Where(x => !x.PluginType.IsOpenGeneric()).ToArray();
closedTypes.Each(
family => {
family.Instances.Each(i => { tryCreateBuildPlan(family.PluginType, i, policies, report); });
});
closedTypes.Each(
family => {
family.Instances.Where(x => !_buildPlanFailureIds.Contains(x.Instance.Id))
.Each(i => { tryBuildInstance(family.PluginType, i.Instance, pipeline, report); });
});
}
private static void determineSetterSource(DependencyCollection dependencies, Policies policies,
PropertyInfo setter,
IHasSetters plan)
{
var isMandatory = policies.IsMandatorySetter(setter);
object dependency = null;
if (setter.PropertyType.IsSimple() && !isMandatory)
{
dependency = dependencies.FindByTypeAndName(setter.PropertyType, setter.Name);
}
else
{
dependency = dependencies.FindByTypeOrName(setter.PropertyType, setter.Name);
}
if (dependency == null && !isMandatory) return;
var source = SourceFor(SetterProperty, setter.Name, setter.PropertyType, dependency);
plan.Add(setter.PropertyType, setter, source);
}
/// <summary>
/// Creates an IDependencySource that can be used to build the object
/// represented by this Instance
/// </summary>
/// <param name="pluginType"></param>
/// <param name="policies"></param>
/// <returns></returns>
public virtual IDependencySource ToBuilder(Type pluginType, Policies policies)
{
return(ToDependencySource(pluginType));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore);
services.AddCors();
services.AddDbContext <SamaDeliveryDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("SqlConnection")),
ServiceLifetime.Transient
);
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "SamaDelivery Api", Version = "v1"
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
In = ParameterLocation.Header,
Description = "Please insert JWT with Bearer into field",
Name = "Authorization",
Type = SecuritySchemeType.ApiKey
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement {
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
}
},
new string[] { }
}
});
});
services.AddIdentity <ApplicationUser, Roles>()
.AddEntityFrameworkStores <SamaDeliveryDbContext>()
.AddDefaultTokenProviders()
.AddSignInManager();
services.Configure <IdentityOptions>(options =>
{
options.Password.RequireDigit = false;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireLowercase = false;
options.Password.RequireUppercase = false;
options.Password.RequiredLength = 4;
});
services.AddFirebase(Configuration, _webHostEnvironment);
services.AddAuthorization(config =>
{
config.AddPolicy(Policies.Admin, Policies.AdminPolicy());
config.AddPolicy(Policies.User, Policies.UserPolicy());
});
services.AddTokenAuthentication(Configuration);
services.AddMvc(options =>
{
options.EnableEndpointRouting = false;
});
services.AddAutoMapper(typeof(MapperProfile));
services.AddTransient <IUserService, UserService>();
services.AddTransient <IEmployeeService, EmployeeService>();
services.AddTransient <IClientService, ClientService>();
services.AddTransient <IPrincipalService, PrincipalService>();
services.AddTransient <IAreaService, AreaService>();
services.AddTransient <IAreaGroupService, AreaGroupService>();
services.AddTransient <ICityService, CityService>();
services.AddTransient <IConfigurationService, ConfigurationService>();
services.AddTransient <IRecordService, RecordService>();
services.AddTransient <IPushNotificationService, PushNotificationService>();
services.AddTransient <IOrderService, OrderService>();
//services.AddTransient<IReportService, ReportService>();
services.AddTransient <IDriverService, DriverService>();
services.AddTransient <IOrderStatusService, OrderStatusService>();
services.AddTransient <IRecordService, RecordService>();
services.AddTransient <IOrderReportReplaysService, OrderReportReplaysService>();
services.AddTransient <IEmployeeService, EmployeeService>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddTransient <IMessageService, MessageService>();
services.AddTransient <IOrderReportService, OrderReportService>();
services.AddTransient <IAdminNotificationService, AdminNotificationService>();
services.AddTransient <IReportService, ReportService>();
services.AddHttpContextAccessor();
}
public static IServiceCollection AddBTCPayServer(this IServiceCollection services, IConfiguration configuration)
{
services.AddDbContext <ApplicationDbContext>((provider, o) =>
{
var factory = provider.GetRequiredService <ApplicationDbContextFactory>();
factory.ConfigureBuilder(o);
o.UseOpenIddict <BTCPayOpenIdClient, BTCPayOpenIdAuthorization, OpenIddictScope <string>, BTCPayOpenIdToken, string>();
});
services.AddHttpClient();
services.AddHttpClient(nameof(ExplorerClientProvider), httpClient =>
{
httpClient.Timeout = Timeout.InfiniteTimeSpan;
});
services.TryAddSingleton <SettingsRepository>();
services.TryAddSingleton <TorServices>();
services.TryAddSingleton <SocketFactory>();
services.TryAddSingleton <LightningClientFactoryService>();
services.TryAddSingleton <InvoicePaymentNotification>();
services.TryAddSingleton <BTCPayServerOptions>(o =>
o.GetRequiredService <IOptions <BTCPayServerOptions> >().Value);
services.AddStartupTask <MigrationStartupTask>();
services.TryAddSingleton <InvoiceRepository>(o =>
{
var opts = o.GetRequiredService <BTCPayServerOptions>();
var dbContext = o.GetRequiredService <ApplicationDbContextFactory>();
var dbpath = Path.Combine(opts.DataDir, "InvoiceDB");
if (!Directory.Exists(dbpath))
{
Directory.CreateDirectory(dbpath);
}
return(new InvoiceRepository(dbContext, dbpath, o.GetRequiredService <BTCPayNetworkProvider>()));
});
services.AddSingleton <BTCPayServerEnvironment>();
services.TryAddSingleton <TokenRepository>();
services.TryAddSingleton <WalletRepository>();
services.TryAddSingleton <EventAggregator>();
services.TryAddSingleton <PaymentRequestService>();
services.TryAddSingleton <U2FService>();
services.TryAddSingleton <CoinAverageSettings>();
services.TryAddSingleton <ApplicationDbContextFactory>(o =>
{
var opts = o.GetRequiredService <BTCPayServerOptions>();
ApplicationDbContextFactory dbContext = null;
if (!String.IsNullOrEmpty(opts.PostgresConnectionString))
{
Logs.Configuration.LogInformation($"Postgres DB used ({opts.PostgresConnectionString})");
dbContext = new ApplicationDbContextFactory(DatabaseType.Postgres, opts.PostgresConnectionString);
}
else if (!String.IsNullOrEmpty(opts.MySQLConnectionString))
{
Logs.Configuration.LogInformation($"MySQL DB used ({opts.MySQLConnectionString})");
dbContext = new ApplicationDbContextFactory(DatabaseType.MySQL, opts.MySQLConnectionString);
}
else
{
var connStr = "Data Source=" + Path.Combine(opts.DataDir, "sqllite.db");
Logs.Configuration.LogInformation($"SQLite DB used ({connStr})");
dbContext = new ApplicationDbContextFactory(DatabaseType.Sqlite, connStr);
}
return(dbContext);
});
services.TryAddSingleton <BTCPayNetworkProvider>(o =>
{
var opts = o.GetRequiredService <BTCPayServerOptions>();
return(opts.NetworkProvider);
});
services.TryAddSingleton <AppService>();
services.TryAddSingleton <Ganss.XSS.HtmlSanitizer>(o =>
{
var htmlSanitizer = new Ganss.XSS.HtmlSanitizer();
htmlSanitizer.RemovingAtRule += (sender, args) =>
{
};
htmlSanitizer.RemovingTag += (sender, args) =>
{
if (args.Tag.TagName.Equals("img", StringComparison.InvariantCultureIgnoreCase))
{
if (!args.Tag.ClassList.Contains("img-fluid"))
{
args.Tag.ClassList.Add("img-fluid");
}
args.Cancel = true;
}
};
htmlSanitizer.RemovingAttribute += (sender, args) =>
{
if (args.Tag.TagName.Equals("img", StringComparison.InvariantCultureIgnoreCase) &&
args.Attribute.Name.Equals("src", StringComparison.InvariantCultureIgnoreCase) &&
args.Reason == Ganss.XSS.RemoveReason.NotAllowedUrlValue)
{
args.Cancel = true;
}
};
htmlSanitizer.RemovingStyle += (sender, args) => { args.Cancel = true; };
htmlSanitizer.AllowedAttributes.Add("class");
htmlSanitizer.AllowedTags.Add("iframe");
htmlSanitizer.AllowedTags.Remove("img");
htmlSanitizer.AllowedAttributes.Add("webkitallowfullscreen");
htmlSanitizer.AllowedAttributes.Add("allowfullscreen");
return(htmlSanitizer);
});
services.TryAddSingleton <LightningConfigurationProvider>();
services.TryAddSingleton <LanguageService>();
services.TryAddSingleton <NBXplorerDashboard>();
services.TryAddSingleton <StoreRepository>();
services.TryAddSingleton <PaymentRequestRepository>();
services.TryAddSingleton <BTCPayWalletProvider>();
services.TryAddSingleton <CurrencyNameTable>();
services.TryAddSingleton <IFeeProviderFactory>(o => new NBXplorerFeeProviderFactory(o.GetRequiredService <ExplorerClientProvider>())
{
Fallback = new FeeRate(100L, 1),
BlockTarget = 20
});
services.AddSingleton <CssThemeManager>();
services.Configure <MvcOptions>((o) => {
o.Filters.Add(new ContentSecurityPolicyCssThemeManager());
o.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(WalletId)));
o.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(DerivationStrategyBase)));
});
services.AddSingleton <IHostedService, CssThemeManagerHostedService>();
services.AddSingleton <IHostedService, HostedServices.CheckConfigurationHostedService>();
services.AddSingleton <BitcoinLikePaymentHandler>();
services.AddSingleton <IPaymentMethodHandler>(provider => provider.GetService <BitcoinLikePaymentHandler>());
services.AddSingleton <IHostedService, NBXplorerListener>();
services.AddSingleton <LightningLikePaymentHandler>();
services.AddSingleton <IPaymentMethodHandler>(provider => provider.GetService <LightningLikePaymentHandler>());
services.AddSingleton <IHostedService, LightningListener>();
services.AddSingleton <PaymentMethodHandlerDictionary>();
services.AddSingleton <ChangellyClientProvider>();
services.AddSingleton <IHostedService, NBXplorerWaiters>();
services.AddSingleton <IHostedService, InvoiceNotificationManager>();
services.AddSingleton <IHostedService, InvoiceWatcher>();
services.AddSingleton <IHostedService, RatesHostedService>();
services.AddSingleton <IHostedService, BackgroundJobSchedulerHostedService>();
services.AddSingleton <IHostedService, AppHubStreamer>();
services.AddSingleton <IHostedService, DynamicDnsHostedService>();
services.AddSingleton <IHostedService, TorServicesHostedService>();
services.AddSingleton <IHostedService, PaymentRequestStreamer>();
services.AddSingleton <IBackgroundJobClient, BackgroundJobClient>();
services.AddTransient <IConfigureOptions <MvcOptions>, BTCPayClaimsFilter>();
services.TryAddSingleton <ExplorerClientProvider>();
services.TryAddSingleton <Bitpay>(o =>
{
if (o.GetRequiredService <BTCPayServerOptions>().NetworkType == NetworkType.Mainnet)
{
return(new Bitpay(new Key(), new Uri("https://bitpay.com/")));
}
else
{
return(new Bitpay(new Key(), new Uri("https://test.bitpay.com/")));
}
});
services.TryAddSingleton <RateProviderFactory>();
services.TryAddSingleton <RateFetcher>();
services.TryAddScoped <IHttpContextAccessor, HttpContextAccessor>();
services.AddTransient <AccessTokenController>();
services.AddTransient <InvoiceController>();
services.AddTransient <AppsPublicController>();
services.AddTransient <PaymentRequestController>();
// Add application services.
services.AddSingleton <EmailSenderFactory>();
// bundling
services.AddAuthorization(o => Policies.AddBTCPayPolicies(o));
services.AddBtcPayServerAuthenticationSchemes(configuration);
services.AddSingleton <IBundleProvider, ResourceBundleProvider>();
services.AddTransient <BundleOptions>(provider =>
{
var opts = provider.GetRequiredService <BTCPayServerOptions>();
var bundle = new BundleOptions();
bundle.UseBundles = opts.BundleJsCss;
bundle.AppendVersion = true;
return(bundle);
});
services.AddCors(options =>
{
options.AddPolicy(CorsPolicies.All, p => p.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin());
});
var rateLimits = new RateLimitService();
rateLimits.SetZone($"zone={ZoneLimits.Login} rate=5r/min burst=3 nodelay");
services.AddSingleton(rateLimits);
return(services);
}
public static IServiceCollection AddBTCPayServer(this IServiceCollection services)
{
services.AddDbContext <ApplicationDbContext>((provider, o) =>
{
var factory = provider.GetRequiredService <ApplicationDbContextFactory>();
factory.ConfigureBuilder(o);
});
services.AddHttpClient();
services.TryAddSingleton <SettingsRepository>();
services.TryAddSingleton <InvoicePaymentNotification>();
services.TryAddSingleton <BTCPayServerOptions>(o => o.GetRequiredService <IOptions <BTCPayServerOptions> >().Value);
services.TryAddSingleton <InvoiceRepository>(o =>
{
var opts = o.GetRequiredService <BTCPayServerOptions>();
var dbContext = o.GetRequiredService <ApplicationDbContextFactory>();
var dbpath = Path.Combine(opts.DataDir, "InvoiceDB");
if (!Directory.Exists(dbpath))
{
Directory.CreateDirectory(dbpath);
}
return(new InvoiceRepository(dbContext, dbpath));
});
services.AddSingleton <BTCPayServerEnvironment>();
services.TryAddSingleton <TokenRepository>();
services.TryAddSingleton <EventAggregator>();
services.TryAddSingleton <CoinAverageSettings>();
services.TryAddSingleton <CrowdfundHubStreamer>();
services.TryAddSingleton <ApplicationDbContextFactory>(o =>
{
var opts = o.GetRequiredService <BTCPayServerOptions>();
ApplicationDbContextFactory dbContext = null;
if (!String.IsNullOrEmpty(opts.PostgresConnectionString))
{
Logs.Configuration.LogInformation($"Postgres DB used ({opts.PostgresConnectionString})");
dbContext = new ApplicationDbContextFactory(DatabaseType.Postgres, opts.PostgresConnectionString);
}
else if (!String.IsNullOrEmpty(opts.MySQLConnectionString))
{
Logs.Configuration.LogInformation($"MySQL DB used ({opts.MySQLConnectionString})");
dbContext = new ApplicationDbContextFactory(DatabaseType.MySQL, opts.MySQLConnectionString);
}
else
{
var connStr = "Data Source=" + Path.Combine(opts.DataDir, "sqllite.db");
Logs.Configuration.LogInformation($"SQLite DB used ({connStr})");
dbContext = new ApplicationDbContextFactory(DatabaseType.Sqlite, connStr);
}
return(dbContext);
});
services.TryAddSingleton <BTCPayNetworkProvider>(o =>
{
var opts = o.GetRequiredService <BTCPayServerOptions>();
return(opts.NetworkProvider);
});
services.TryAddSingleton <AppsHelper>();
services.TryAddSingleton <LightningConfigurationProvider>();
services.TryAddSingleton <LanguageService>();
services.TryAddSingleton <NBXplorerDashboard>();
services.TryAddSingleton <StoreRepository>();
services.TryAddSingleton <BTCPayWalletProvider>();
services.TryAddSingleton <CurrencyNameTable>();
services.TryAddSingleton <IFeeProviderFactory>(o => new NBXplorerFeeProviderFactory(o.GetRequiredService <ExplorerClientProvider>())
{
Fallback = new FeeRate(100, 1),
BlockTarget = 20
});
services.AddSingleton <CssThemeManager>();
services.Configure <MvcOptions>((o) => {
o.Filters.Add(new ContentSecurityPolicyCssThemeManager());
o.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(WalletId)));
o.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(typeof(DerivationStrategyBase)));
});
services.AddSingleton <IHostedService, CssThemeManagerHostedService>();
services.AddSingleton <IHostedService, MigratorHostedService>();
services.AddSingleton <Payments.IPaymentMethodHandler <DerivationStrategy>, Payments.Bitcoin.BitcoinLikePaymentHandler>();
services.AddSingleton <IHostedService, Payments.Bitcoin.NBXplorerListener>();
services.AddSingleton <IHostedService, HostedServices.CheckConfigurationHostedService>();
services.AddSingleton <Payments.IPaymentMethodHandler <Payments.Lightning.LightningSupportedPaymentMethod>, Payments.Lightning.LightningLikePaymentHandler>();
services.AddSingleton <LightningLikePaymentHandler>();
services.AddSingleton <IHostedService, Payments.Lightning.LightningListener>();
services.AddSingleton <ChangellyClientProvider>();
services.AddSingleton <IHostedService, NBXplorerWaiters>();
services.AddSingleton <IHostedService, InvoiceNotificationManager>();
services.AddSingleton <IHostedService, InvoiceWatcher>();
services.AddSingleton <IHostedService, RatesHostedService>();
services.AddTransient <IConfigureOptions <MvcOptions>, BTCPayClaimsFilter>();
services.TryAddSingleton <ExplorerClientProvider>();
services.TryAddSingleton <Bitpay>(o =>
{
if (o.GetRequiredService <BTCPayServerOptions>().NetworkType == NetworkType.Mainnet)
{
return(new Bitpay(new Key(), new Uri("https://bitpay.com/")));
}
else
{
return(new Bitpay(new Key(), new Uri("https://test.bitpay.com/")));
}
});
services.TryAddSingleton <RateProviderFactory>();
services.TryAddSingleton <RateFetcher>();
services.TryAddScoped <IHttpContextAccessor, HttpContextAccessor>();
services.AddTransient <AccessTokenController>();
services.AddTransient <InvoiceController>();
services.AddTransient <AppsPublicController>();
// Add application services.
services.AddTransient <IEmailSender, EmailSender>();
// bundling
services.AddAuthorization(o => Policies.AddBTCPayPolicies(o));
BitpayAuthentication.AddAuthentication(services);
services.AddBundles();
services.AddTransient <BundleOptions>(provider =>
{
var opts = provider.GetRequiredService <BTCPayServerOptions>();
var bundle = new BundleOptions();
bundle.UseBundles = opts.BundleJsCss;
bundle.AppendVersion = true;
return(bundle);
});
services.AddCors(options =>
{
options.AddPolicy(CorsPolicies.All, p => p.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin());
});
var rateLimits = new RateLimitService();
rateLimits.SetZone($"zone={ZoneLimits.Login} rate=5r/min burst=3 nodelay");
services.AddSingleton(rateLimits);
return(services);
}
public void is_valid_sad_path_with_setter_checks()
{
// This class needs all three of these things
var dependencies = new DependencyCollection();
dependencies.Add("Name", "Jeremy");
dependencies.Add("Age", 40);
//dependencies.Add("IsAwake", true);
ConcreteType.BuildSource(typeof(GuyWithPrimitiveSetters), null, dependencies, Policies.Default())
.IsValid().ShouldBeFalse();
}
protected IEnumerable<IInterceptor> determineInterceptors(Type pluginType, Policies policies)
{
var interceptors =
policies.Interceptors.SelectInterceptors(pluginType, this).Union(_interceptors);
return interceptors;
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
var authAuthority = Configuration["BlazorBoilerplate:IS4ApplicationUrl"].TrimEnd('/');
services.RegisterStorage(Configuration);
var migrationsAssembly = typeof(ApplicationDbContext).GetTypeInfo().Assembly.GetName();
var migrationsAssemblyName = migrationsAssembly.Name;
var useSqlServer = Convert.ToBoolean(Configuration["BlazorBoilerplate:UseSqlServer"] ?? "false");
var dbConnString = useSqlServer
? Configuration.GetConnectionString("DefaultConnection")
: $"Filename={Configuration.GetConnectionString("SqlLiteConnectionFileName")}";
void DbContextOptionsBuilder(DbContextOptionsBuilder builder)
{
if (useSqlServer)
{
builder.UseSqlServer(dbConnString, sql => sql.MigrationsAssembly(migrationsAssemblyName));
}
else if (Convert.ToBoolean(Configuration["BlazorBoilerplate:UsePostgresServer"] ?? "false"))
{
builder.UseNpgsql(Configuration.GetConnectionString("PostgresConnection"), sql => sql.MigrationsAssembly(migrationsAssemblyName));
}
else
{
builder.UseSqlite(dbConnString, sql => sql.MigrationsAssembly(migrationsAssemblyName));
}
}
services.Configure <ApiBehaviorOptions>(options => { options.SuppressModelStateInvalidFilter = true; });
services.AddDbContext <ApplicationDbContext>(DbContextOptionsBuilder);
services.AddIdentity <ApplicationUser, IdentityRole <Guid> >()
.AddRoles <IdentityRole <Guid> >()
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
services.AddScoped <IUserClaimsPrincipalFactory <ApplicationUser>,
AdditionalUserClaimsPrincipalFactory>();
// cookie policy to deal with temporary browser incompatibilities
services.AddSameSiteCookiePolicy();
// Adds IdentityServer
var identityServerBuilder = services.AddIdentityServer(options =>
{
options.IssuerUri = authAuthority;
options.Events.RaiseErrorEvents = true;
options.Events.RaiseInformationEvents = true;
options.Events.RaiseFailureEvents = true;
options.Events.RaiseSuccessEvents = true;
})
.AddIdentityServerStores(Configuration)
.AddConfigurationStore(options =>
{
options.ConfigureDbContext = DbContextOptionsBuilder;
})
.AddOperationalStore(options =>
{
options.ConfigureDbContext = DbContextOptionsBuilder;
// this enables automatic token cleanup. this is optional.
options.EnableTokenCleanup = true;
options.TokenCleanupInterval = 3600; //In Seconds 1 hour
})
.AddAspNetIdentity <ApplicationUser>();
X509Certificate2 cert = null;
if (_environment.IsDevelopment())
{
// The AddDeveloperSigningCredential extension creates temporary key material for signing tokens.
// This might be useful to get started, but needs to be replaced by some persistent key material for production scenarios.
// See http://docs.identityserver.io/en/release/topics/crypto.html#refcrypto for more information.
// https://stackoverflow.com/questions/42351274/identityserver4-hosting-in-iis
//.AddDeveloperSigningCredential(true, @"C:\tempkey.rsa")
identityServerBuilder.AddDeveloperSigningCredential();
}
else
{
// running on azure
// please make sure to replace your vault URI and your certificate name in appsettings.json!
if (Convert.ToBoolean(Configuration["HostingOnAzure:RunsOnAzure"]) == true)
{
// if we use a key vault
if (Convert.ToBoolean(Configuration["HostingOnAzure:AzurekeyVault:UsingKeyVault"]) == true)
{
// if managed app identity is used
if (Convert.ToBoolean(Configuration["HostingOnAzure:AzurekeyVault:UseManagedAppIdentity"]) == true)
{
try
{
AzureServiceTokenProvider azureServiceTokenProvider = new AzureServiceTokenProvider();
var keyVaultClient = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
var certificateBundle = keyVaultClient.GetSecretAsync(Configuration["HostingOnAzure:AzureKeyVault:VaultURI"], Configuration["HostingOnAzure:AzurekeyVault:CertificateName"]).GetAwaiter().GetResult();
var certificate = System.Convert.FromBase64String(certificateBundle.Value);
cert = new X509Certificate2(certificate, (string)null, X509KeyStorageFlags.MachineKeySet);
}
catch (Exception ex)
{
throw (ex);
}
}
// if app id and app secret are used
if (Convert.ToBoolean(Configuration["HostingOnAzure:AzurekeyVault:UsingKeyVault"]) == false)
{
throw new NotImplementedException();
}
}
}
// using local cert store
if (Convert.ToBoolean(Configuration["BlazorBoilerplate:UseLocalCertStore"]) == true)
{
var certificateThumbprint = Configuration["BlazorBoilerplate:CertificateThumbprint"];
using (X509Store store = new X509Store("WebHosting", StoreLocation.LocalMachine))
{
store.Open(OpenFlags.ReadOnly);
var certs = store.Certificates.Find(X509FindType.FindByThumbprint, certificateThumbprint, false);
if (certs.Count > 0)
{
cert = certs[0];
}
else
{
// import PFX
cert = new X509Certificate2(Path.Combine(_environment.ContentRootPath, "AuthSample.pfx"), "Admin123",
X509KeyStorageFlags.MachineKeySet |
X509KeyStorageFlags.PersistKeySet |
X509KeyStorageFlags.Exportable);
// save certificate and private key
X509Store storeMy = new X509Store(StoreName.CertificateAuthority, StoreLocation.LocalMachine);
storeMy.Open(OpenFlags.ReadWrite);
storeMy.Add(cert);
}
store.Close();
}
}
// pass the resulting certificate to Identity Server
if (cert != null)
{
identityServerBuilder.AddSigningCredential(cert);
}
else
{
throw new FileNotFoundException("No certificate for Identity Server could be retrieved.");
}
}
var authBuilder = services.AddAuthentication(options =>
{
options.DefaultScheme = IdentityServerAuthenticationDefaults.AuthenticationScheme;
})
.AddIdentityServerAuthentication(options =>
{
options.Authority = authAuthority;
options.SupportedTokens = SupportedTokens.Jwt;
options.RequireHttpsMetadata = _environment.IsProduction() ? true : false;
options.ApiName = IdentityServerConfig.ApiName;
});
//https://docs.microsoft.com/en-us/aspnet/core/security/authentication/social/google-logins?view=aspnetcore-3.1
if (Convert.ToBoolean(Configuration["ExternalAuthProviders:Google:Enabled"] ?? "false"))
{
authBuilder.AddGoogle(options =>
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
options.ClientId = Configuration["ExternalAuthProviders:Google:ClientId"];
options.ClientSecret = Configuration["ExternalAuthProviders:Google:ClientSecret"];
});
}
//Add Policies / Claims / Authorization - https://stormpath.com/blog/tutorial-policy-based-authorization-asp-net-core
services.AddAuthorization(options =>
{
options.AddPolicy(Policies.IsAdmin, Policies.IsAdminPolicy());
options.AddPolicy(Policies.IsUser, Policies.IsUserPolicy());
options.AddPolicy(Policies.IsReadOnly, Policies.IsReadOnlyPolicy());
options.AddPolicy(Policies.IsMyDomain, Policies.IsMyDomainPolicy()); // valid only on serverside operations
});
services.AddSingleton <IAuthorizationPolicyProvider, AuthorizationPolicyProvider>();
services.AddTransient <IAuthorizationHandler, DomainRequirementHandler>();
services.AddTransient <IAuthorizationHandler, PermissionRequirementHandler>();
services.Configure <IdentityOptions>(options =>
{
// Password settings
options.Password.RequireDigit = false;
options.Password.RequiredLength = 6;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
//options.Password.RequiredUniqueChars = 6;
// Lockout settings
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
options.Lockout.MaxFailedAccessAttempts = 10;
options.Lockout.AllowedForNewUsers = true;
// Require Confirmed Email User settings
if (Convert.ToBoolean(Configuration["BlazorBoilerplate:RequireConfirmedEmail"] ?? "false"))
{
options.User.RequireUniqueEmail = false;
options.SignIn.RequireConfirmedEmail = true;
}
});
// services.Configure<CookiePolicyOptions>(options =>
// {
// options.MinimumSameSitePolicy = SameSiteMode.None;
// });
//services.ConfigureExternalCookie(options =>
// {
// macOS login fix
//options.Cookie.SameSite = SameSiteMode.None;
//});
services.ConfigureApplicationCookie(options =>
{
// macOS login fix
//options.Cookie.SameSite = SameSiteMode.None;
//options.Cookie.HttpOnly = false;
// Suppress redirect on API URLs in ASP.NET Core -> https://stackoverflow.com/a/56384729/54159
options.Events = new CookieAuthenticationEvents()
{
OnRedirectToAccessDenied = context =>
{
if (context.Request.Path.StartsWithSegments("/api"))
{
context.Response.StatusCode = Status403Forbidden;
}
return(Task.CompletedTask);
},
OnRedirectToLogin = context =>
{
context.Response.StatusCode = Status401Unauthorized;
return(Task.CompletedTask);
}
};
});
services.AddControllers().AddNewtonsoftJson();
services.AddSignalR();
services.AddSwaggerDocument(config =>
{
config.PostProcess = document =>
{
document.Info.Version = migrationsAssembly.Version.ToString();
document.Info.Title = "Blazor Boilerplate";
#if ServerSideBlazor
document.Info.Description = "Blazor Boilerplate / Starter Template using the Server Side Version";
#endif
#if ClientSideBlazor
document.Info.Description = "Blazor Boilerplate / Starter Template using the Client Side / Webassembly Version.";
#endif
};
});
services.AddScoped <IUserSession, UserSession>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton <IEmailConfiguration>(Configuration.GetSection("EmailConfiguration").Get <EmailConfiguration>());
services.AddTransient <IAccountManager, AccountManager>();
services.AddTransient <IAdminManager, AdminManager>();
services.AddTransient <IApiLogManager, ApiLogManager>();
services.AddTransient <IEmailManager, EmailManager>();
services.AddTransient <IExternalAuthManager, ExternalAuthManager>(); // Currently not being used.
services.AddTransient <IMessageManager, MessageManager>();
services.AddTransient <ITodoManager, ToDoManager>();
services.AddTransient <IUserProfileManager, UserProfileManager>();
//Automapper to map DTO to Models https://www.c-sharpcorner.com/UploadFile/1492b1/crud-operations-using-automapper-in-mvc-application/
var automapperConfig = new MapperConfiguration(configuration =>
{
configuration.AddProfile(new MappingProfile());
});
var autoMapper = automapperConfig.CreateMapper();
services.AddSingleton(autoMapper);
#if ServerSideBlazor
services.AddScoped <IAuthorizeApi, AuthorizeApi>();
services.AddScoped <IUserProfileApi, UserProfileApi>();
services.AddScoped <AppState>();
services.AddMatToaster(config =>
{
config.Position = MatToastPosition.BottomRight;
config.PreventDuplicates = true;
config.NewestOnTop = true;
config.ShowCloseButton = true;
config.MaximumOpacity = 95;
config.VisibleStateDuration = 3000;
});
// Setup HttpClient for server side
services.AddScoped <HttpClient>();
services.AddRazorPages();
services.AddServerSideBlazor();
// Authentication providers
Log.Logger.Debug("Removing AuthenticationStateProvider...");
var serviceDescriptor = services.FirstOrDefault(descriptor => descriptor.ServiceType == typeof(AuthenticationStateProvider));
if (serviceDescriptor != null)
{
services.Remove(serviceDescriptor);
}
Log.Logger.Debug("Adding AuthenticationStateProvider...");
services.AddScoped <AuthenticationStateProvider, IdentityAuthenticationStateProvider>();
#endif
Log.Logger.Debug($"Total Services Registered: {services.Count}");
foreach (var service in services)
{
Log.Logger.Debug($"\n Service: {service.ServiceType.FullName}\n Lifetime: {service.Lifetime}\n Instance: {service.ImplementationType?.FullName}");
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <AppDbContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("DefaultConnection"),
b => b.MigrationsAssembly("Trial-Task-WEB")));
services.AddHangfire(configuration => configuration
.SetDataCompatibilityLevel(CompatibilityLevel.Version_170)
.UseSimpleAssemblyNameTypeSerializer()
.UseRecommendedSerializerSettings()
.UseSqlServerStorage(Configuration.GetConnectionString("HangfireConnection"), new SqlServerStorageOptions
{
CommandBatchMaxTimeout = TimeSpan.FromMinutes(5),
SlidingInvisibilityTimeout = TimeSpan.FromMinutes(5),
QueuePollInterval = TimeSpan.Zero,
UseRecommendedIsolationLevel = true,
UsePageLocksOnDequeue = true,
DisableGlobalLocks = true
}));
// Add the processing server as IHostedService
services.AddHangfireServer();
services.AddIdentity <User, IdentityRole <Guid> >().AddEntityFrameworkStores <AppDbContext>();
services.ConfigureApplicationCookie(options =>
{
options.LoginPath = new PathString("/User/login");
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "My API", Version = "v1"
});
});
services.AddScoped <IAirfieldRepository, AirfieldRepository>();
services.AddScoped <IAirfieldService, AirfieldService>();
services.AddScoped <IFlightRepository, FlightRepository>();
services.AddScoped <IFlightService, FlightService>();
services.AddScoped <IGPSLogEntryRepository, GPSLogEntryRepository>();
services.AddScoped <IGPSLogEntryService, GPSLogEntryService>();
services.AddScoped <IGPSLogRepository, GPSLogRepository>();
services.AddScoped <IGPSLogService, GPSLogService>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IIGCFileRecordRepository, IGCFileRecordRepository>();
services.AddScoped <IIGCFileRecordService, IGCFileRecordService>();
services.AddScoped <IAPIFlightsController, APIFlightsController>();
services.AddScoped <IAPIUsersController, APIUsersController>();
services.AddScoped <IAPIAirfieldsController, APIAirfieldsController>();
var mappingConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new MappingProfile());
});
IMapper mapper = mappingConfig.CreateMapper();
services.AddSingleton(mapper);
services.AddSingleton <IFileProvider>(
new PhysicalFileProvider(
Path.Combine(Directory.GetCurrentDirectory(), "wwwroot")));
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddAuthorization(options =>
{
options.AddPolicy(Policies.MEMBERS, Policies.GetAuthorizationPolicy(Policies.MEMBERS));
options.AddPolicy(Policies.ADMINS, Policies.GetAuthorizationPolicy(Policies.ADMINS));
options.AddPolicy(Policies.RESTRICTED, Policies.GetAuthorizationPolicy(Policies.RESTRICTED));
});
}
public void ApplyAllPolicies(Type pluginType, Policies policies)
{
lock (_buildLock)
{
policies.Apply(pluginType, this);
}
}
public static async Task Main(string[] args)
{
//Update service registrations that depend on IAccessTokenProvider to be scoped services instead of singleton services!
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add <App>("app");
builder.Services.AddSingleton(new HttpClient {
BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});
builder.Services.AddOidcAuthentication(options =>
{
//builder.Configuration.Bind("Local", options.ProviderOptions);
// Configure your authentication provider options here.
// For more information, see https://aka.ms/blazor-standalone-auth
options.ProviderOptions.Authority = "http://localhost:5000"; // "https://localhost:5001";
options.ProviderOptions.ClientId = "blazorstandalone";
options.ProviderOptions.ResponseType = "code"; //this is fundamental to talk to Identity Server 4
options.ProviderOptions.DefaultScopes.Add("photos"); //you add these so that the user can consent
options.ProviderOptions.DefaultScopes.Add("photosrest");
options.ProviderOptions.DefaultScopes.Add("comments"); //and the access token contains the granted audiences
});
#region grpcPhotos
// builder.Services.AddSingleton(services =>
// {
//#if DEBUG
// var backendUrl = "https://localhost:5011"; // Local debug URL
//#else
// var backendUrl = "https://localhost:5011"; // Production URL
//#endif
// // Now we can instantiate gRPC clients for this channel
// var httpClient = new HttpClient(new GrpcWebHandler(GrpcWebMode.GrpcWeb, new HttpClientHandler()));
// var channel = GrpcChannel.ForAddress(backendUrl, new GrpcChannelOptions { HttpClient = httpClient });
// return new Photosthingpackage.PhotosThing.PhotosThingClient(channel);
// });
// builder.Services.AddTransient<IPhotosService, PhotosService>();
// builder.Services.AddTransient<IPhotosRepository, PhotosGrpcClient>();
#endregion
#region WebApiPhotos
builder.Services.AddSingleton(
new HttpClient
{
BaseAddress = new Uri("https://localhost:5041/api/photos/")
});
builder.Services.AddTransient <IPhotosService, PhotosService>();
builder.Services.AddTransient <IPhotosRepository, PhotosApiClient>();
#endregion
#region gRPCComments
builder.Services.AddSingleton(services =>
{
#if DEBUG
var backendUrl = "https://localhost:5021"; // Local debug URL
#else
var backendUrl = "https://localhost:5021"; // Production URL
#endif
// Now we can instantiate gRPC clients for this channel
var httpClient = new HttpClient(new GrpcWebHandler(GrpcWebMode.GrpcWeb, new HttpClientHandler()));
var channel = GrpcChannel.ForAddress(backendUrl, new GrpcChannelOptions {
HttpClient = httpClient
});
return(new Commentsthingpackage.CommentsThing.CommentsThingClient(channel));
});
#endregion
builder.Services.AddTransient <ICommentsService, CommentsService>();
builder.Services.AddTransient <ICommentsRepository, CommentsGrpcClient>();
builder.Services
.AddBlazorise(options =>
{
options.ChangeTextOnKeyPress = true;
})
.AddBootstrapProviders()
.AddFontAwesomeIcons();
builder.Services.AddAuthorizationCore(options =>
{
options.AddPolicy(Policies.EditDeletePhoto, Policies.CanEditDeletePhotoPolicy());
options.AddPolicy(Policies.EditDeleteComment, Policies.CanEditDeleteCommentPolicy());
});
builder.Services.AddSingleton <IAuthorizationHandler, PhotoEditDeleteAuthorizationHandler>();
builder.Services.AddSingleton <IAuthorizationHandler, CommentEditDeleteAuthorizationHandler>();
var host = builder.Build();
host.Services
.UseBootstrapProviders()
.UseFontAwesomeIcons();
await host.RunAsync();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(options =>
{
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = true,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = Configuration["Jwt:Issuer"],
ValidAudience = Configuration["Jwt:Audience"],
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Jwt:SecretKey"])),
ClockSkew = TimeSpan.Zero
};
});
services.AddAuthorization(config =>
{
config.AddPolicy(Policies.Admin, Policies.AdminPolicy());
config.AddPolicy(Policies.Support, Policies.SupportPolicy());
config.AddPolicy(Policies.Partner, Policies.PartnerPolicy());
config.AddPolicy(Policies.Vendors, Policies.VendorsPolicy());
config.AddPolicy(Policies.Temp, Policies.TempPolicy());
});
services.AddControllersWithViews();
services.AddControllers();
services.AddCors(o => o.AddPolicy("CorsPolicy", builder =>
{
builder
.WithOrigins("http://localhost:4200", "*")
.AllowAnyMethod()
.AllowAnyHeader()
.SetIsOriginAllowed((host) => true)
.AllowCredentials();
}));
services.AddControllers().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore);
services.AddDbContext <RiaDBContext>(options => options.UseNpgsql(Configuration.GetConnectionString("DefaultConnection")));
services.AddScoped <IRepository, Repository <RiaDBContext> >();
//services.AddSwaggerGen(options =>
//{
// options.SwaggerDoc("v2", new Microsoft.OpenApi.Models.OpenApiInfo
// {
// Title = "Freight-Easy",
// Version = "v2",
// Description = "Sample service for Freight-Easy",
// });
//});
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/dist";
});
}
private void GetOnlineDocuments()
{
WebMethods webapi = new WebMethods();
if (DataItems != null)
{
SetDocumentDetails();
}
else
{
webapi.GetPolicies();
}
webapi.policysEvent += ((WebMethods webAPISender, EventArgs e2) =>
{
Device.BeginInvokeOnMainThread(() =>
{
PolicyModel.DocType[] PolicyDocTypes = SimpleJson.DeserializeObject <PolicyModel.DocType[]>(webAPISender.Polocysresponse);
List <Policies> OfflineList = new List <Policies>();
foreach (PolicyModel.DocType dst in PolicyDocTypes)
{
DataItems = new ObservableCollection <DocumentItem>();
int i = 0;
PolicySubTypes = new string[5];
foreach (PolicyModel.DocSubType pd in dst.DocSubTypes)
{
PolicySubTypes[i] = pd.Name.ToString();
DocumentType dt3 = new DocumentType {
DocumentTypeId = i, DocumentTypeTitle = pd.Name.ToString()
};
int j = 0;
foreach (PolicyModel.Document orgDoc in pd.Documents)
{
//await App.PersonRepo.AddNewPersonAsync(orgDoc.DocumentName);
DocumentItem pdi = new DocumentItem();
pdi.DocumentItemId = j;
pdi.DocumentItemTitle = orgDoc.DocumentName;
pdi.DocumentType = dt3;
DataItems.Add(pdi);
//from here
Policies OfflineSingleP = new Policies();
OfflineSingleP.DocName = orgDoc.DocumentName;
OfflineList.Add(OfflineSingleP);
OfflineSingleP = null;
//till here
j = j + 1;
}
i = i + 1;
}
//DocumentTypes = new ObservableCollection<Grouping<SelectDocumentTypeViewModel, DocumentItem>>();
if (DataItems != null)
{
SetDocumentDetails();
}
}
});
});
}
public WebRegistry()
{
Scan(scan =>
{
scan.TheCallingAssembly();
scan.ConnectImplementationsToTypesClosing(typeof(IHandleEvent <>));
});
// For action filters
Policies.SetAllProperties(x =>
{
x.OfType <Func <IUnitOfWork> >();
x.OfType <Func <IRepository <User> > >();
});
// Mvc
For <IFilterProvider>().Use <StructureMapFilterProvider>();
// Customers
For <ICustomerStartupTask>().Add <CustomerDatabaseStartupTask>();
ForSingletonOf <ICustomerHost>().Use <WebAppHost>();
For <ICustomerResolver>()
.Use <DatabaseCustomerResolver>()
.Ctor <string>()
.Is(ConfigurationManager.ConnectionStrings[Constants.MasterConnectionStringName].ConnectionString);
For <CustomerInstance>()
.Use(() => HttpContext.Current.Items[Constants.CurrentCustomerInstanceKey] as CustomerInstance)
.LifecycleIs <HttpContextLifecycle>();
// Data
For <EFDbContext>().Use(() => new EFDbContext(Settings.ConnectionString)).LifecycleIs <HttpContextLifecycle>();
For(typeof(IRepository <>)).Use(typeof(EFRespository <>)).LifecycleIs <HttpContextLifecycle>();
// UoW
For <IUnitOfWork>().Use <EFUnitOfWork>().LifecycleIs <HttpContextLifecycle>();
For <IUserRepository>().Use <UserRepository>();
For <IRoleRepository>().Use <RoleRepository>();
For <IReferenceListRepository>().Use <ReferenceListRepository>();
For <IReferenceListItemRepository>().Use <ReferenceListItemRepository>();
For <IApiTokenRepository>().Use <ApiTokenRepository>();
For <IApiSessionTokenRepository>().Use <ApiSessionTokenRepository>();
For <IPlanRepository>().Use <PlanRepository>();
For <ICustomerRepository>().Use <CustomerRepository>();
For <IEmailTemplatesRepository>().Use <EmailTemplatesRepository>();
For <IPlanInfoRepository>().Use <PlanInfoRepository>();
For <IPlanInfoValueRepository>().Use <PlanInfoValueRepository>();
For <IAuditEntryRepository>().Use <AuditEntryRepository>();
For <ILog4NetRepository>().Use <Log4NetRepository>();
For <ICustomerPaymentRepository>().Use <CustomerPaymentRepository>();
For <ICustomerPaymentRefundRepository>().Use <CustomerPaymentRefundRepository>();
For <IProjectRepository>().Use <ProjectRepository>();
For <INoteRepository>().Use <NoteRepository>();
// Security
For <ILoginManager>().Use <FormsLoginManager>();
// Infrastructure
// Eventing
For <IEventBus>().Use <EventBus>();
For <IEventHandlerFactory>().Use <StructureMapEventHandlerFactory>();
Events.RegisterEventBus(() => ObjectFactory.GetInstance <IEventBus>());
DomainEvents.RegisterEventBus(() => ObjectFactory.GetInstance <IEventBus>());
// Domain
For <INotificationTransport>().Add <EFNotificationTransport>();
For <INotificationTransport>().Add <SignalRNotificationTransport>();
For <INotificationCenter>().Use <NotificationCenter>();
//Services
For <IUserService>().Use <UserService>();
For <IRoleService>().Use <RoleService>();
For <IReferenceListService>().Use <ReferenceListService>();
For <IApiTokenService>().Use <ApiTokenService>();
For <IApiSessionTokenService>().Use <ApiSessionTokenService>();
For <IPlanService>().Use <PlanService>();
For <ISubscriptionsService>().Use <SubscriptionsService>();
For <IUserNotificationService>().Use <UserNotificationService>();
For <ICustomerService>().Use <CustomerService>();
For <IEmailTemplatesService>().Use <EmailTemplatesService>();
For <IAuditEntryService>().Use <AuditEntryService>();
For <ICustomerDashboardService>().Use <ProjectService>();
// Infrastructure
For <IEmailService>().Use <EmailService>().SelectConstructor(() => new EmailService());
For <IMailService>().Use <SendGridSMTPService>();
For <ISchedulerClient>().Use <QuartzSchedulerClient>().Ctor <string>().Is(Constants.QuartzSchedulerAddressSettingKey);
// Logger
For <ILogger>().Use <LogAdapter>();
// Application Settings
For <IApplicationSettings>().Use <WebConfigApplicationSettings>();
//Stripe
For <IStripeService>().Use <StripeAdapter>();
}
public void AutoFillDeterminationWithSetterPropertiesIsTrue()
{
Policies.Default().CanBeAutoFilled(typeof(AutoFilledGridColumn))
.ShouldBeTrue();
}
public RESTStatus ConnectWSServerMappingPort(SQLLib sql, NetInt64 ID, NetworkConnectionInfo ni)
{
if (ni.HasAcl(ACLFlags.ComputerLogin) == false)
{
ni.Error = "Access denied";
ni.ErrorID = ErrorFlags.AccessDenied;
return(RESTStatus.Denied);
}
List <PolicyObject> pols = Policies.GetPolicyForComputerInternal(sql, ni.Username);
PolicyObject FoundPolicy = null;
foreach (PolicyObject p in pols)
{
if (p.ID == ID.Data && p.Type == PolicyIDs.PortMapping)
{
FoundPolicy = p;
break;
}
}
if (FoundPolicy == null)
{
ni.Error = "Not found";
ni.ErrorID = ErrorFlags.NotAccepted;
return(RESTStatus.Denied);
}
PortMappingPolicy pmp = JsonConvert.DeserializeObject <PortMappingPolicy>(Policies.GetPolicy(sql, FoundPolicy.ID).Data);
IPAddress ip;
IPHostEntry ipaddr;
if (IPAddress.TryParse(pmp.ServerServer, out ip) == false)
{
ipaddr = Dns.GetHostEntry(pmp.ServerServer);
}
else
{
ipaddr = new IPHostEntry();
ipaddr.AddressList = new IPAddress[] { ip };
}
if (ipaddr == null)
{
ni.Error = "Cannot resolve";
ni.ErrorID = ErrorFlags.NoData;
return(RESTStatus.Fail);
}
if (ipaddr.AddressList.Length == 0)
{
ni.Error = "Resolve - no data";
ni.ErrorID = ErrorFlags.NoData;
return(RESTStatus.Fail);
}
Socket socket;
try
{
socket = new Socket(ipaddr.AddressList[0].AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(ipaddr.AddressList[0], pmp.ServerPort);
}
catch (Exception ee)
{
Debug.WriteLine("Cannot connect " + ee.ToString());
ni.Error = "Resolve - no data";
ni.ErrorID = ErrorFlags.NoData;
return(RESTStatus.Fail);
}
string SessionID = "";
RemoteNetworkConnectionWSCrosser.CreateCustomAgentConnection <WS_ServerPortMappingConnection>(ni.Username, ref SessionID, i => i.InitThis(ref SessionID, socket));
Res = new PushConnectNetworkResult();
Res.ConnectedGUID = SessionID;
Res.Result = 0;
return(RESTStatus.Success);
}
/// <summary>
/// Creates an IDependencySource that can be used to build the object
/// represented by this Instance
/// </summary>
/// <param name="pluginType"></param>
/// <param name="policies"></param>
/// <returns></returns>
public virtual IDependencySource ToBuilder(Type pluginType, Policies policies)
{
return ToDependencySource(pluginType);
}
public BuildPlan(Type pluginType, Instance instance, IDependencySource inner, Policies policies,
IEnumerable <IInterceptor> interceptors)
{
PluginType = pluginType;
Instance = instance;
Inner = inner;
if (interceptors.Any())
{
_interceptionPlan = new InterceptionPlan(pluginType, Inner, policies, interceptors);
}
var @delegate = ToDelegate();
_func = @delegate as Func <IBuildSession, IContext, object>;
}
/// <summary>
/// Resolves the IBuildPlan for this Instance. The result is remembered
/// for subsequent requests
/// </summary>
/// <param name="pluginType"></param>
/// <param name="policies"></param>
/// <returns></returns>
public IBuildPlan ResolveBuildPlan(Type pluginType, Policies policies)
{
if (_plan == null)
{
lock (_buildLock)
{
if (_plan == null)
{
_plan = buildPlan(pluginType, policies);
}
}
}
return _plan;
}
protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context,
PolicyRequirement requirement)
{
if (context.User.Identity.AuthenticationType != GreenFieldConstants.AuthenticationType)
{
return;
}
var userid = _userManager.GetUserId(context.User);
bool success = false;
var policy = requirement.Policy;
var requiredUnscoped = false;
if (policy.EndsWith(':'))
{
policy = policy.Substring(0, policy.Length - 1);
requiredUnscoped = true;
}
switch (policy)
{
case { } when Policies.IsStorePolicy(policy):
var storeId = _HttpContext.GetImplicitStoreId();
// Specific store action
if (storeId != null)
{
if (context.HasPermission(Permission.Create(policy, storeId), requiredUnscoped))
{
if (string.IsNullOrEmpty(userid))
{
break;
}
var store = await _storeRepository.FindStore(storeId, userid);
if (store == null)
{
break;
}
if (Policies.IsStoreModifyPolicy(policy) || policy == Policies.CanUseLightningNodeInStore)
{
if (store.Role != StoreRoles.Owner)
{
break;
}
}
success = true;
_HttpContext.SetStoreData(store);
}
}
else
{
if (requiredUnscoped && !context.HasPermission(Permission.Create(policy)))
{
break;
}
var stores = await _storeRepository.GetStoresByUserId(userid);
List <StoreData> permissionedStores = new List <StoreData>();
foreach (var store in stores)
{
if (context.HasPermission(Permission.Create(policy, store.Id), requiredUnscoped))
{
permissionedStores.Add(store);
}
}
_HttpContext.SetStoresData(permissionedStores.ToArray());
success = true;
}
break;
case { } when Policies.IsServerPolicy(policy):
if (context.HasPermission(Permission.Create(policy)))
{
var user = await _userManager.GetUserAsync(context.User);
if (user == null)
{
break;
}
if (!await _userManager.IsInRoleAsync(user, Roles.ServerAdmin))
{
break;
}
success = true;
}
break;
case Policies.CanManageNotificationsForUser:
case Policies.CanViewNotificationsForUser:
case Policies.CanModifyProfile:
case Policies.CanViewProfile:
case Policies.CanDeleteUser:
case Policies.Unrestricted:
success = context.HasPermission(Permission.Create(policy), requiredUnscoped);
break;
}
if (success)
{
context.Succeed(requirement);
}
}
private static IRequestOptions GetRequestOptions(QueryOptions queryOptions = null, Policies policies = null)
{
return(RequestHandlerTests.GetConfig(queryOptions, policies).DefaultRequestOptions);
}
public async Task <IActionResult> AuthorizeAPIKey(string[] permissions, string applicationName = null, Uri redirect = null,
bool strict = true, bool selectiveStores = false, string applicationIdentifier = null)
{
if (!_btcPayServerEnvironment.IsSecure)
{
TempData.SetStatusMessageModel(new StatusMessageModel()
{
Severity = StatusMessageModel.StatusSeverity.Error,
Message = "Cannot generate api keys while not on https or tor"
});
return(RedirectToAction("APIKeys"));
}
permissions ??= Array.Empty <string>();
var requestPermissions = Permission.ToPermissions(permissions);
if (redirect?.IsAbsoluteUri is false)
{
redirect = null;
}
if (!string.IsNullOrEmpty(applicationIdentifier) && redirect != null)
{
//check if there is an app identifier that matches and belongs to the current user
var keys = await _apiKeyRepository.GetKeys(new APIKeyRepository.APIKeyQuery()
{
UserId = new[] { _userManager.GetUserId(User) }
});
foreach (var key in keys)
{
var blob = key.GetBlob();
if (blob.ApplicationIdentifier != applicationIdentifier ||
blob.ApplicationAuthority != redirect.AbsoluteUri)
{
continue;
}
//matched the identifier and authority, but we need to check if what the app is requesting in terms of permissions is enough
var alreadyPresentPermissions = Permission.ToPermissions(blob.Permissions)
.GroupBy(permission => permission.Policy);
var fail = false;
foreach (var permission in requestPermissions.GroupBy(permission => permission.Policy))
{
var presentPermission =
alreadyPresentPermissions.SingleOrDefault(grouping => permission.Key == grouping.Key);
if (strict && presentPermission == null)
{
fail = true;
break;
}
if (Policies.IsStorePolicy(permission.Key))
{
if (!selectiveStores &&
permission.Any(permission1 => !string.IsNullOrEmpty(permission1.Scope)))
{
TempData.SetStatusMessageModel(new StatusMessageModel()
{
Severity = StatusMessageModel.StatusSeverity.Error,
Message =
"Cannot request specific store permission when selectiveStores is not enable"
});
return(RedirectToAction("APIKeys"));
}
else if (!selectiveStores && presentPermission.Any(permission1 =>
!string.IsNullOrEmpty(permission1.Scope)))
{
fail = true;
break;
}
}
}
if (fail)
{
continue;
}
//we have a key that is sufficient, redirect to a page to confirm that it's ok to provide this key to the app.
return(View("ConfirmAPIKey",
new AuthorizeApiKeysViewModel()
{
ApiKey = key.Id,
RedirectUrl = redirect,
Label = applicationName,
ApplicationName = applicationName,
SelectiveStores = selectiveStores,
Strict = strict,
Permissions = string.Join(';', permissions),
ApplicationIdentifier = applicationIdentifier
}));
}
}
var vm = await SetViewModelValues(new AuthorizeApiKeysViewModel()
{
RedirectUrl = redirect,
Label = applicationName,
ApplicationName = applicationName,
SelectiveStores = selectiveStores,
Strict = strict,
Permissions = string.Join(';', requestPermissions),
ApplicationIdentifier = applicationIdentifier
});
AdjustVMForAuthorization(vm);
return(View(vm));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//tblerror.Description = "Started";
//_context.TblErrorlog.Add(tblerror);
//_context.SaveChanges();
try
{
services.AddSignalR();
services.AddCors(options => options.AddPolicy("AllowAny", x => {
x.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin();
}));
services.AddControllers();
services.AddSwaggerGen(c =>
{
// c.SwaggerDoc(name: "v1", new OpenApiInfo { Title = "Core API", Description = "Swagger Core API" });
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "Core API",
Description = "Swagger Core API"
});
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Name = "Authorization",
Type = SecuritySchemeType.ApiKey,
Scheme = "Bearer",
BearerFormat = "JWT",
In = ParameterLocation.Header,
Description = "Please insert JWT with Bearer into field"
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement {
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
}
},
new string[] { }
}
});
var xmlPath = System.AppDomain.CurrentDomain.BaseDirectory + @"TaxiAppsWebAPICore.xml";
c.IncludeXmlComments(xmlPath);
});
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = true,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = Configuration.GetValue <string>("Jwt:Issuer"), //"https://localhost:44374/",
ValidAudience = Configuration.GetValue <string>("Jwt:Audience"), //https://localhost:44374/"
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration.GetValue <string>("Jwt:SecretKey"))), // new SymmetricSecurityKey(Encoding.UTF8.GetBytes("nplustechnologies")),
ClockSkew = TimeSpan.Zero
};
});
services.AddAuthorization(config =>
{
config.AddPolicy(Policies.Admin, Policies.AdminPolicy());
config.AddPolicy(Policies.superAdmin, Policies.superAdminPolicy());
config.AddPolicy(Policies.User, Policies.UserPolicy());
});
services.AddDbContext <TaxiAppzDBContext>(
//Options => Options.UseSqlServer(Configuration.GetConnectionString("TaxiAppzDB")).UseLazyLoadingProxies());
Options => Options.UseSqlServer(Configuration.GetConnectionString("TaxiAppzDB")));
services.AddControllersWithViews()
.AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
);
services.AddMvc(option => option.EnableEndpointRouting = false);
services.AddOptions();
services.AddMvc();
// var cors = EnableCor(Configuration);
// services.AddCors(options =>
//{
// options.AddPolicy("AllowAll", builder =>
// {
// builder.AllowAnyOrigin();
// });
//});
services.Configure <JWT>(Configuration.GetSection("Jwt"));
services.AddScoped <IToken, Token>();
}
catch (Exception ex)
{
TaxiAppzDBContext _context = new TaxiAppzDBContext();
TblErrorlog tblerror = new TblErrorlog();
tblerror.FunctionName = "ConfigureServices";
tblerror.CreatedBy = "Startup.cs";
tblerror.Description = ex.Message;
_context.TblErrorlog.Add(tblerror);
_context.SaveChanges();
}
}
public void ConfigureServices(IServiceCollection services)
{
services.AddApplicationInsightsTelemetry(options =>
{
options.ConnectionString = _configuration.GetConnectionString("ApplicationInsights");
});
services.AddDbContext <RutrackerContext>(options =>
{
options.UseLazyLoadingProxies();
options.UseSqlServer(_configuration.GetConnectionString("SqlServer"),
sqlServerOptions =>
{
sqlServerOptions.EnableRetryOnFailure();
});
});
services.AddMemoryCache();
services.Configure <JwtOptions>(_configuration.GetSection("JwtOptions"));
services.Configure <ClientOptions>(_configuration.GetSection("ClientOptions"));
services.Configure <EmailAuthOptions>(_configuration.GetSection("EmailAuthOptions"));
services.Configure <FileOptions>(_configuration.GetSection("FileOptions"));
services.AddResponseCompression(options =>
{
options.EnableForHttps = true;
})
.Configure <GzipCompressionProviderOptions>(options =>
{
options.Level = CompressionLevel.Optimal;
});
services.AddSwaggerGen(options =>
{
// Add the XML comment file for this assembly, so it's contents can be displayed.
var file = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var filePath = Path.Combine(AppContext.BaseDirectory, file);
options.IncludeXmlComments(filePath, includeControllerXmlComments: true);
options.SwaggerDoc(name: "v1", new OpenApiInfo
{
Title = "Rutracker API",
Description = "The current version of the API",
Version = "v1"
});
});
services.AddAutoMapper(typeof(Startup));
services.AddIdentity <User, Role>(options =>
{
options.SignIn.RequireConfirmedAccount = false;
options.SignIn.RequireConfirmedEmail = false;
options.SignIn.RequireConfirmedPhoneNumber = false;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
options.Password.RequireDigit = false;
options.Password.RequiredLength = 6;
})
.AddRoles <Role>()
.AddEntityFrameworkStores <RutrackerContext>()
.AddDefaultTokenProviders();
services.ConfigureApplicationCookie(options =>
{
options.ExpireTimeSpan = TimeSpan.FromDays(1);
options.SlidingExpiration = true;
});
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
var jwtSettings = _configuration.GetSection("JwtOptions").Get <JwtOptions>();
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.ClaimsIssuer = jwtSettings.Issuer;
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidIssuer = jwtSettings.Issuer,
ValidateAudience = true,
ValidAudience = jwtSettings.Audience,
ValidateIssuerSigningKey = true,
IssuerSigningKey = jwtSettings.SigningKey,
RequireExpirationTime = false,
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero
};
});
services.AddAuthorization(options =>
{
options.AddPolicy(Policies.IsUser, Policies.IsUserPolicy());
options.AddPolicy(Policies.IsAdmin, Policies.IsAdminPolicy());
});
services.AddControllers(options =>
{
options.Filters.Add <GlobalExceptionFilter>();
options.Filters.Add <ValidatorFilter>();
options.OutputFormatters.RemoveType <StreamOutputFormatter>();
options.OutputFormatters.RemoveType <StringOutputFormatter>();
})
.AddNewtonsoftJson()
.ConfigureApiBehaviorOptions(options =>
{
options.SuppressModelStateInvalidFilter = true;
});
services.AddIdentitySeed();
services.AddSingleton <IJwtService, JwtService>();
services.AddSingleton <IEmailSender, EmailSender>();
services.AddSingleton <IEmailService, EmailService>();
services.AddScoped <IUnitOfWork <RutrackerContext>, RutrackerUnitOfWork>();
services.AddScoped <IDateService, DateService>();
services.AddScoped <IAccountService, AccountService>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IRoleService, RoleService>();
services.AddScoped <ICategoryService, CategoryService>();
services.AddScoped <ISubcategoryService, SubcategoryService>();
services.AddScoped <ITorrentService, TorrentService>();
services.AddScoped <IFileService, FileService>();
services.AddScoped <ICommentService, CommentService>();
services.AddScoped <IStorageService, StorageService>();
}
//public bool CallWebService()
//{
// // Do you webservice call here //
// Device.BeginInvokeOnMainThread(() =>
// {
// StackLoadingRef.IsVisible = false;
// });
// return false;
//}
public DocumentTypes(string isComingFrom)
{
InitializeComponent();
//Device.BeginInvokeOnMainThread(() =>
//{
// StackLoadingRef.IsVisible = true;
//});
//Device.StartTimer(new TimeSpan(0, 0, 10), CallWebService); //20 seconds
string returnOS = DependencyService.Get <DependencyServices.INetworkDependency>().IsNetworkAvailable();
NavigationPage.SetHasNavigationBar(this, false);
if (isComingFrom == "favorite")
{
homeimage.Source = "Home_gray.png";
imgFavorite.Source = "fav_gray.png";
searchRef.Image = "search_activate.png";
docsofflinedata = App.PoliciesRepo.GetAllPolicies();
listViewDocsRef.ItemsSource = docsofflinedata;
StacksearchRef.IsVisible = true;
}
else
{
StacksearchRef.IsVisible = false;
}
searchBarRef.TextChanged += (object sender, TextChangedEventArgs e) =>
{
try{
if (searchBarRef.Text.Length > 0)
{
listViewDocsRef.ItemsSource = docsofflinedata.Where(x => x.DocName.Contains(searchBarRef.Text)).ToList();
listViewDocsRef.IsVisible = true;
cancelbtnRef.IsVisible = true;
searchitem = searchBarRef.Text;
}
if (searchBarRef.Text.Length == 0)
{
listViewDocsRef.ItemsSource = null;
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
searchBarRef.SearchButtonPressed += (sender, e) =>
{
try
{
docsBySearchItem = docsofflinedata.Where(x => x.DocName.Contains(searchBarRef.Text)).ToList();
Navigation.PushAsync(new SearchItemsListPage(docsBySearchItem, searchitem));
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
cancelbtnRef.Clicked += (object sender, EventArgs e) =>
{
try
{
StacksearchRef.IsVisible = false;
listViewDocsRef.IsVisible = false;
cancelbtnRef.IsVisible = false;
if (searchBarRef.Text.Length > 0)
{
searchBarRef.Text = "";
}
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
// searchBarRef.Placeholder = "";
searchRef.Clicked += (object sender, EventArgs e) =>
{
//NavigateByDocType("CEHSP");
try{
homeimage.Source = "Home_gray.png";
imgFavorite.Source = "fav_gray.png";
searchRef.Image = "search_activate.png";
docsofflinedata = App.PoliciesRepo.GetAllPolicies();
listViewDocsRef.ItemsSource = docsofflinedata;
StacksearchRef.IsVisible = true;
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
btnCEHSP.Clicked += (object sender, EventArgs e) =>
{
//NavigateByDocType("CEHSP");
try{
NavigateByTabDocType("CEHSP");
}
catch (Exception ex)
{
//Debug.WriteLine(ex.Message);
logger.Error(ex.Message);
}
};
btnCEHSI.Clicked += (object sender, EventArgs e) =>
{
//NavigateByDocType("GEHSI");
try{
NavigateByTabDocType("GEHSI");
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
btnManual.Clicked += (object sender, EventArgs e) =>
{
//NavigateByDocType("Manual");
try{
NavigateByTabDocType("Manual");
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
btnGuidance.Clicked += (object sender, EventArgs e) =>
{
try{
NavigateByTabDocType("EH&S Guidance");
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
btnEnvSpec.Clicked += (object sender, EventArgs e) =>
{
try{
NavigateByTabDocType("ES");
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
btnRuleBook.Clicked += (object sender, EventArgs e) =>
{
try{
NavigateByTabDocType("Rule Book");
}
catch (Exception ex)
{
//Debug.WriteLine(ex.Message);
logger.Error(ex.Message);
}
};
btnCEHSPLand.Clicked += (object sender, EventArgs e) =>
{
//NavigateByDocType("CEHSP");
try
{
NavigateByTabDocType("CEHSP");
}
catch (Exception ex)
{
//Debug.WriteLine(ex.Message);
logger.Error(ex.Message);
}
};
btnCEHSILand.Clicked += (object sender, EventArgs e) =>
{
//NavigateByDocType("GEHSI");
try
{
NavigateByTabDocType("GEHSI");
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
btnManualLand.Clicked += (object sender, EventArgs e) =>
{
//NavigateByDocType("Manual");
try
{
NavigateByTabDocType("Manual");
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
btnGuidanceLand.Clicked += (object sender, EventArgs e) =>
{
try
{
NavigateByTabDocType("EH&S Guidance");
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
btnEnvSpecLand.Clicked += (object sender, EventArgs e) =>
{
try
{
NavigateByTabDocType("ES");
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
};
btnRuleBookLand.Clicked += (object sender, EventArgs e) =>
{
try
{
NavigateByTabDocType("Rule Book");
}
catch (Exception ex)
{
//Debug.WriteLine(ex.Message);
logger.Error(ex.Message);
}
};
listViewDocsRef.ItemSelected += (sender, e) =>
{
// activityIndicatorLayout.IsVisible = true;
try{
Policies di = new Policies();
di = (Policies)e.SelectedItem;
string docName = di.DocName; //di.DocumentItemTitle;
bool isFavorite = di.IsFavourite; // di.IsFavorite;
di = null;
ViewDocument dd = new ViewDocument(docName, isFavorite);
Label lblTitle = dd.FindByName <Label>("lblVDTitle");
lblTitle.Text = "Policies And Procedures";
Navigation.PushAsync(dd);
dd = null;
}
catch (Exception ex)
{
//Debug.WriteLine(ex.Message);
logger.Error(ex.Message);
}
//activityIndicatorLayout.IsVisible = false;
};
var tabclosegesture = new TapGestureRecognizer();
tabclosegesture.Tapped += (object sender, EventArgs e) =>
{
try{
StacksearchRef.IsVisible = false;
searchRef.Image = "search_gray.png";
homeimage.Source = "Home_activate.png";
}
catch (Exception ex)
{
//Debug.WriteLine(ex.Message);
logger.Error(ex.Message);
}
};
StacksearchRef.GestureRecognizers.Add(tabclosegesture);
tabclosegesture.NumberOfTapsRequired = 1;
}
public override IDependencySource ToBuilder(Type pluginType, Policies policies)
{
throw new NotSupportedException("FuncWithArgFactoryTemplatedoes not support ToBuilder");
}
protected override IBuildPlan buildPlan(Type pluginType, Policies policies)
{
return(this);
}
public InfrastructureWeb()
{
// Enable property injection on HTTP handlers as we can't do constructor injection with them
// (StructureMap doesn't do property injection by default)
Policies.SetAllProperties(s => s.Matching(p => p.DeclaringType != null && p.DeclaringType.GetInterface("IHttpHandler") != null));
}
public void ConfigureServices(IServiceCollection services)
{
services.AddCors(options =>
{
options.AddPolicy(DebugPolicyName, b => b.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials()
// only for the vue development server
.WithOrigins("http://localhost:8080"));
});
services.AddDbContext <GameDbContext>(builder => builder.UseSqlite(Configuration.GetConnectionString("Default"),
b => b.MigrationsAssembly(nameof(WerewolfCircle))));
IConfiguration jwtConfiguration = Configuration.GetSection("Jwt");
services.AddOptions <JwtConfig>()
.Bind(jwtConfiguration);
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
JwtConfig jwtConfig = jwtConfiguration.Get <JwtConfig>();
options.RequireHttpsMetadata = !WebHostEnvironment.IsDevelopment();
options.SaveToken = true;
options.TokenValidationParameters = new TokenValidationParameters
{
RequireExpirationTime = true,
RequireSignedTokens = true,
RequireAudience = true,
SaveSigninToken = false,
TryAllIssuerSigningKeys = true,
ValidateActor = false,
ValidateAudience = true,
ValidateIssuer = true,
ValidateIssuerSigningKey = false,
ValidateLifetime = true,
ValidateTokenReplay = false,
ValidIssuer = jwtConfig.Issuer,
ValidAudience = jwtConfig.Audience,
IssuerSigningKey = jwtConfig.BuildSecretSecurityKey(),
ClockSkew = TimeSpan.Zero,
// These two things need to be done since we don't want to use Microsofts claim names (see Program.cs).
NameClaimType = JwtRegisteredClaimNames.GivenName, // set User.Identity.Name to the player name (which is unique within the game).
RoleClaimType = JwtConfig.RoleClaimType // respect the specified role for authorization.
};
options.Events = new JwtBearerEvents
{
OnMessageReceived = context =>
{
StringValues accessToken = context.Request.Query["access_token"];
PathString path = context.HttpContext.Request.Path;
if (!string.IsNullOrEmpty(accessToken) &&
path.StartsWithSegments(GameHubRoute))
{
// Read the token out of the query string (browser limitation for WebSockets)
context.Token = accessToken;
}
return(Task.CompletedTask);
}
};
});
services.AddAuthorization(options =>
{
options.AddPolicy(Policies.AdminPolicyName, Policies.BuildAdminPolicy());
});
services.AddControllers();
services.AddSignalR();
services.AddSingleton <IUserIdProvider, NameUserIdProvider>();
services.AddTransient <IRoomIdGenerator, NanoRoomIdGenerator>();
services.AddTransient <IAuthTokenGenerator, JwtTokenGenerator>();
}
public static IDependencySource SourceFor(Policies policies, string ctorOrSetter, string name, Type dependencyType, object value)
{
if (value == null)
{
if (dependencyType.IsNonNullableSimple())
{
return(new DependencyProblem
{
Message = MissingPrimitiveWarning,
Type = ctorOrSetter,
Name = name,
ReturnedType = dependencyType
});
}
return(new DefaultDependencySource(dependencyType));
}
if (value is IDependencySource)
{
return(value as IDependencySource);
}
if (value is Instance)
{
var instance = value.As <Instance>();
if (instance.Interceptors.Any())
{
var inner = instance.ToDependencySource(dependencyType);
return(new InterceptionPlan(dependencyType, inner, policies, instance.Interceptors));
}
else
{
return(instance.ToDependencySource(dependencyType));
}
}
if (value.GetType().CanBeCastTo(dependencyType))
{
return(new Constant(dependencyType, value));
}
if (dependencyType.IsSimple())
{
try
{
return(new Constant(dependencyType, ConvertType(value, dependencyType)));
}
catch (Exception)
{
return(new DependencyProblem
{
Type = ctorOrSetter,
Name = name,
ReturnedType = dependencyType,
Message =
CastingError.ToFormat(value, value.GetType().GetFullName(), dependencyType.GetFullName())
});
}
}
if (EnumerableInstance.IsEnumerable(dependencyType))
{
var coercion = EnumerableInstance.DetermineCoercion(dependencyType);
var coercedValue = coercion.Convert(value.As <IEnumerable <object> >());
return(new Constant(dependencyType, coercedValue));
}
return(new DependencyProblem
{
Type = ctorOrSetter,
Name = name,
ReturnedType = dependencyType,
Message = UnableToDetermineDependency.ToFormat(dependencyType.GetFullName(), value)
});
}
private static void _Draw(Rect rect, Pawn pawn)
{
Policy policy = pawn.GetPolicyAssignedTo();
Text.Anchor = TextAnchor.MiddleLeft;
// -------------------- Top left --------------------------
Rect topRect = new Rect(rect.position.x + horizontalMargin, rect.position.y + verticalMargin, topRectSize.x - horizontalMargin * 2, topRectSize.y);
Listing_Standard listing = new Listing_Standard(topRect);
listing.ColumnWidth = topRect.width / 2;
listing.verticalSpacing = 4;
Text.Anchor = TextAnchor.MiddleCenter;
//listingLeft.Label("PawnPolicyCard_Policy".Translate());
string readable = pawn.GetPolicyAssignedTo().label;
var flag = pawn.HasHardcodedPolicy();
if (flag)
{
listing.Label(string.Format("{0} ({1})", "PawnPolicyCard_CannotSetPolicy".Translate(), policy.label));
}
else
{
if (listing.ButtonTextLabeled("PawnPolicyCard_Policy".Translate(), readable))
{
var floatOptions = new List <FloatMenuOption>();
var policies = Policies.GetAllPoliciesForPawn(pawn)
#if !DEBUG
.Where(arg => arg.Visible)
#endif
;
foreach (var item in policies)
{
floatOptions.Add(new FloatMenuOption(item.label, () => WorldDataStore_PawnPolicies.SetPolicyForPawn(pawn, item), MenuOptionPriority.Default,
delegate
{
//TODO: policy tooltip
}));
}
Find.WindowStack.Add(new FloatMenu(floatOptions));
}
}
listing.NewColumn();
// -------------------- Top right --------------------------
Thing bestFood;
ThingDef bestFoodDef;
string bestFoodInfo;
if (FoodUtility.TryFindBestFoodSourceFor(pawn, pawn, true, out bestFood, out bestFoodDef))
{
bestFoodInfo = bestFood.Label;
if (pawn.inventory != null && pawn.inventory.innerContainer.Contains(bestFood))
{
bestFoodInfo += " " + "PawnPolicyCard_Inventory".Translate();
}
}
else
{
bestFoodInfo = "PawnPolicyCard_NoFoodFound".Translate();
}
listing.Label(string.Format("PawnPolicyCard_CurrentBestFood".Translate(), bestFoodInfo));
//var mask = PawnMask.MakeCompleteMaskFromPawn(pawn);
//listing.Label(mask.ToString());
listing.End();
// -------------------- Top end --------------------------
Widgets.DrawLineHoriz ontal(rect.x + horizontalMargin, rect.y + topRectSize.y - verticalMargin, rect.width - horizontalMargin * 2);
// ---------------------------- Middle -------------------------------
Rect policyRectMiddle = new Rect(rect.x + horizontalMargin, rect.y + topRectSize.y, middleRectSize.x - horizontalMargin, middleRectSize.y);
// ---------------------------- Middle left -------------------------------
Listing_Standard listingMiddleLeft = new Listing_Standard(policyRectMiddle.LeftPart(middleLeftColumnSize / policyRectMiddle.width));
listingMiddleLeft.verticalSpacing = verticalMargin;
//listingMiddleLeft.ColumnWidth = middleLeftColumnSize;
//Rect policyRectMiddleLeft = policyRectMiddle.LeftHalf();
Text.Font = GameFont.Small;
//string policyDesc = "";
//Rect policyRectMiddleLeft_inner = new Rect(0, 0, policyRectMiddleLeft.width, policyRectMiddleLeft.height * 2);
//Widgets.BeginScrollView(policyRectMiddleLeft, ref scrollposition, policyRectMiddleLeft_inner);
//var listingMiddleLeft_inner = new Listing_Standard(policyRectMiddleLeft);
Text.Anchor = TextAnchor.UpperLeft;
if (policy.description != null && policy.description.Any())
{
listingMiddleLeft.Label(policy.description);
}
else
{
listingMiddleLeft.Label("(No description)"); //TODO: lang file
}
{
var font = Text.Font;
Text.Font = GameFont.Tiny;
listingMiddleLeft.Label(policy.GetDietForPawn(pawn).ToString());
Text.Font = font;
}
listingMiddleLeft.End();
//Widgets.EndScrollView();
// ----------------------------- Middle right ----------------------------------
var rectMiddleRight = policyRectMiddle.RightPart((middleRightColumnSize - horizontalMargin * 4) / policyRectMiddle.width);
rectMiddleRight.x -= horizontalMargin;
Listing_Standard listingMiddleRight = new Listing_Standard(rectMiddleRight);
listingMiddleRight.verticalSpacing = verticalMargin;
if (!flag)
{
Text.Anchor = TextAnchor.MiddleCenter;
listingMiddleRight.verticalSpacing = verticalMargin;
if (listingMiddleRight.ButtonText("PawnPolicyCard_ResetPolicy".Translate()))
{
WorldDataStore_PawnPolicies.SetPolicyForPawn(pawn, null);
}
//if (listingRight.ButtonText(string.Format("PawnPolicyCard_AssignToAll".Translate(), pawn.def.label)))
//{
// WorldDataStore_PawnPolicies.AssignToAllPawnsOfRaces(policy,pawn.def);
//}
{
string targetGroupName = "";
Func <Pawn, bool> validator = null;
if (pawn.IsColonist)
{
validator = (arg) => arg.IsColonist;
targetGroupName = "colonists".Translate();
}
else if (pawn.IsPrisonerOfColony)
{
validator = (arg) => arg.IsPrisonerOfColony;
targetGroupName = "prisoners".Translate();
}
//TODO: setter for rescued pawns
//else if (pawn.HostFaction != null && pawn.HostFaction.IsPlayer)
//{
// validator = (arg) => (pawn.HostFaction != null && pawn.HostFaction.IsPlayer);
// targetGroupName = "guests".Translate();
//}
else if (pawn.Faction.IsPlayer && pawn.RaceProps.Animal)
{
validator = (arg) => (pawn.Faction.IsPlayer && arg.RaceProps.Animal && arg.def == pawn.def);
targetGroupName = pawn.def.label;
}
if (validator != null)
{
if (listingMiddleRight.ButtonText(string.Format("PawnPolicyCard_AssignToAllOnMap".Translate(), targetGroupName)))
{
WorldDataStore_PawnPolicies.AssignToAllPawnsMatchingOnMap(policy, validator);
}
if (listingMiddleRight.ButtonText(string.Format("PawnPolicyCard_ResetAllOnMap".Translate(), targetGroupName)))
{
WorldDataStore_PawnPolicies.AssignToAllPawnsMatchingOnMap(null, validator);
}
}
}
}
listingMiddleRight.End();
}
public static BuildUpPlan BuildUpPlan(Type pluggedType, DependencyCollection dependencies, Policies policies)
{
var plan = new BuildUpPlan(pluggedType);
determineSetterSources(pluggedType, dependencies, policies, plan);
return(plan);
}
public FakeBuildSession()
{
Policies = new Policies();
}
public static ConstructorStep BuildConstructorStep(Type pluggedType, ConstructorInfo constructor,
DependencyCollection dependencies, Policies policies)
{
var ctor = constructor ?? policies.SelectConstructor(pluggedType, dependencies);
if (ctor == null)
{
throw new StructureMapConfigurationException(
"No public constructor could be selected for concrete type " + pluggedType.GetFullName());
}
var ctorStep = new ConstructorStep(ctor);
var multiples = findTypesWithMultipleParametersRequired(ctor);
var ctorDependencies = ctor
.GetParameters()
.Select(x => {
var dependency = multiples.Contains(x.ParameterType)
? dependencies.FindByTypeAndName(x.ParameterType, x.Name)
: dependencies.FindByTypeOrName(x.ParameterType, x.Name);
if (dependency == null && ((x.DefaultValue != null && x.DefaultValue.GetType().Name != "DBNull")))
{
dependency = x.DefaultValue;
}
return(SourceFor(policies, ConstructorArgument, x.Name, x.ParameterType, dependency));
});
ctorStep.Add(ctorDependencies);
return(ctorStep);
}
/// <summary>
/// Resolves the IBuildPlan for this Instance. The result is remembered
/// for subsequent requests
/// </summary>
/// <param name="pluginType"></param>
/// <param name="policies"></param>
/// <returns></returns>
public IBuildPlan ResolveBuildPlan(Type pluginType, Policies policies)
{
lock (_buildLock)
{
return _plan ?? (_plan = buildPlan(pluginType, policies));
}
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
string migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
//assemble the connection string from docker-compose variables
string constring = $"Server={Configuration.GetValue<string>("DOCKER_COMPOSE_SQL")};Database=master;User={Configuration.GetValue<string>("MSSQL_USER")};Password={Configuration.GetValue<string>("SA_PASSWORD")}";
services.AddDbContext <ApplicationDbContext>(options => {
if (!String.IsNullOrWhiteSpace(Configuration.GetValue <string>("DOCKER_COMPOSE_SQL")))
{
options.UseSqlServer(constring); // SQL Server from docker-compose
}
else if (Convert.ToBoolean(Configuration["BlazorBoilerplate:UseSqlServer"] ?? "false"))
{
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"), sql => sql.MigrationsAssembly(migrationsAssembly));//SQL Server Database
}
else
{
options.UseSqlite($"Filename={Configuration.GetConnectionString("SqlLiteConnectionFileName")}", sql => sql.MigrationsAssembly(migrationsAssembly)); // Sql Lite / file database
}
});
services.AddIdentity <ApplicationUser, IdentityRole <Guid> >()
.AddRoles <IdentityRole <Guid> >()
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
services.AddScoped <IUserClaimsPrincipalFactory <ApplicationUser>,
AdditionalUserClaimsPrincipalFactory>();
// Adds IdentityServer
var identityServerBuilder = services.AddIdentityServer(options =>
{
options.IssuerUri = "blazorboilerplate_spa";
options.Events.RaiseErrorEvents = true;
options.Events.RaiseInformationEvents = true;
options.Events.RaiseFailureEvents = true;
options.Events.RaiseSuccessEvents = true;
})
.AddConfigurationStore(options =>
{
options.ConfigureDbContext = builder => {
if (!String.IsNullOrWhiteSpace(Configuration.GetValue <string>("DOCKER_COMPOSE_SQL")))
{
builder.UseSqlServer(constring, sql => sql.MigrationsAssembly(migrationsAssembly)); // SQL Server from docker-compose
}
else if (Convert.ToBoolean(Configuration["BlazorBoilerplate:UseSqlServer"] ?? "false"))
{
builder.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"), sql => sql.MigrationsAssembly(migrationsAssembly)); //SQL Server Database
}
else
{
builder.UseSqlite($"Filename={Configuration.GetConnectionString("SqlLiteConnectionFileName")}", sql => sql.MigrationsAssembly(migrationsAssembly)); // Sql Lite / file database
}
};
})
.AddOperationalStore(options =>
{
options.ConfigureDbContext = builder => {
if (!String.IsNullOrWhiteSpace(Configuration.GetValue <string>("DOCKER_COMPOSE_SQL")))
{
builder.UseSqlServer(constring, sql => sql.MigrationsAssembly(migrationsAssembly)); // SQL Server from docker-compose
}
else
if (Convert.ToBoolean(Configuration["BlazorBoilerplate:UseSqlServer"] ?? "false"))
{
builder.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"), sql => sql.MigrationsAssembly(migrationsAssembly)); //SQL Server Database
}
else
{
builder.UseSqlite($"Filename={Configuration.GetConnectionString("SqlLiteConnectionFileName")}", sql => sql.MigrationsAssembly(migrationsAssembly)); // Sql Lite / file database
}
};
// this enables automatic token cleanup. this is optional.
options.EnableTokenCleanup = true;
options.TokenCleanupInterval = 3600; //In Seconds 1 hour
})
.AddAspNetIdentity <ApplicationUser>();
X509Certificate2 cert = null;
if (_environment.IsDevelopment())
{
// The AddDeveloperSigningCredential extension creates temporary key material for signing tokens.
// This might be useful to get started, but needs to be replaced by some persistent key material for production scenarios.
// See http://docs.identityserver.io/en/release/topics/crypto.html#refcrypto for more information.
// https://stackoverflow.com/questions/42351274/identityserver4-hosting-in-iis
//.AddDeveloperSigningCredential(true, @"C:\tempkey.rsa")
identityServerBuilder.AddDeveloperSigningCredential();
}
else
{
// Works for IIS, finds cert by the thumbprint in appsettings.json
// Make sure Certificate is in the Web Hosting folder && installed to LocalMachine or update settings below
var useLocalCertStore = Convert.ToBoolean(Configuration["BlazorBoilerplate:UseLocalCertStore"]);
var certificateThumbprint = Configuration["BlazorBoilerplate:CertificateThumbprint"];
if (useLocalCertStore)
{
using (X509Store store = new X509Store("WebHosting", StoreLocation.LocalMachine))
{
store.Open(OpenFlags.ReadOnly);
var certs = store.Certificates.Find(X509FindType.FindByThumbprint, certificateThumbprint, false);
//Console.WriteLine("Certificat count = " + certs.Count);
//Console.WriteLine("Certificate path = " + StoreName.CertificateAuthority);
if (certs.Count > 0)
{
cert = certs[0];
}
else
{
// import PFX
cert = new X509Certificate2(Path.Combine(_environment.ContentRootPath, "AuthSample.pfx"), "Admin123",
X509KeyStorageFlags.MachineKeySet |
X509KeyStorageFlags.PersistKeySet |
X509KeyStorageFlags.Exportable);
// save certificate and private key
X509Store storeMy = new X509Store(StoreName.CertificateAuthority, StoreLocation.LocalMachine);
storeMy.Open(OpenFlags.ReadWrite);
storeMy.Add(cert);
}
store.Close();
}
}
else
{
// Azure deployment, will be used if deployed to Azure - Not tested
//var vaultConfigSection = Configuration.GetSection("Vault");
//var keyVaultService = new KeyVaultCertificateService(vaultConfigSection["Url"], vaultConfigSection["ClientId"], vaultConfigSection["ClientSecret"]);
////cert = keyVaultService.GetCertificateFromKeyVault(vaultConfigSection["CertificateName"]);
/// I was informed that this will work as a temp solution in Azure
cert = new X509Certificate2("AuthSample.pfx", "Admin123",
X509KeyStorageFlags.MachineKeySet |
X509KeyStorageFlags.PersistKeySet |
X509KeyStorageFlags.Exportable);
}
identityServerBuilder.AddSigningCredential(cert);
}
services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
.AddIdentityServerAuthentication(options =>
{
options.Authority = Configuration["BlazorBoilerplate:IS4ApplicationUrl"].TrimEnd('/');
options.SupportedTokens = SupportedTokens.Jwt;
options.RequireHttpsMetadata = _environment.IsProduction() ? true : false;
options.ApiName = IdentityServerConfig.ApiName;
});
services.Configure <ApiBehaviorOptions>(options => { options.SuppressModelStateInvalidFilter = true; });
//Add Policies / Claims / Authorization - https://stormpath.com/blog/tutorial-policy-based-authorization-asp-net-core
services.AddAuthorization(options =>
{
options.AddPolicy(Policies.IsAdmin, Policies.IsAdminPolicy());
options.AddPolicy(Policies.IsUser, Policies.IsUserPolicy());
options.AddPolicy(Policies.IsReadOnly, Policies.IsReadOnlyPolicy());
options.AddPolicy(Policies.IsMyDomain, Policies.IsMyDomainPolicy()); // valid only on serverside operations
});
services.AddTransient <IAuthorizationHandler, DomainRequirementHandler>();
services.Configure <IdentityOptions>(options =>
{
// Password settings
options.Password.RequireDigit = false;
options.Password.RequiredLength = 6;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
//options.Password.RequiredUniqueChars = 6;
// Lockout settings
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
options.Lockout.MaxFailedAccessAttempts = 10;
options.Lockout.AllowedForNewUsers = true;
// Require Confirmed Email User settings
if (Convert.ToBoolean(Configuration["BlazorBoilerplate:RequireConfirmedEmail"] ?? "false"))
{
options.User.RequireUniqueEmail = false;
options.SignIn.RequireConfirmedEmail = true;
}
});
services.ConfigureApplicationCookie(options =>
{
options.Cookie.HttpOnly = false;
// Suppress redirect on API URLs in ASP.NET Core -> https://stackoverflow.com/a/56384729/54159
options.Events = new CookieAuthenticationEvents()
{
OnRedirectToAccessDenied = context =>
{
if (context.Request.Path.StartsWithSegments("/api"))
{
context.Response.StatusCode = (int)(HttpStatusCode.Unauthorized);
}
return(Task.CompletedTask);
},
OnRedirectToLogin = context =>
{
context.Response.StatusCode = 401;
return(Task.CompletedTask);
}
};
});
services.AddControllers().AddNewtonsoftJson();
services.AddSignalR();
services.AddSwaggerDocument(config =>
{
config.PostProcess = document =>
{
document.Info.Version = "v0.2.3";
document.Info.Title = "Blazor Boilerplate";
document.Info.Description = "Blazor Boilerplate / Starter Template using the (ASP.NET Core Hosted) (dotnet new blazorhosted) model. Hosted by an ASP.NET Core server";
};
});
services.AddResponseCompression(opts =>
{
opts.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(
new[] { "application/octet-stream" });
});
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped <IUserSession, UserSession>();
services.AddSingleton <IEmailConfiguration>(Configuration.GetSection("EmailConfiguration").Get <EmailConfiguration>());
services.AddTransient <IEmailService, EmailService>();
services.AddTransient <IUserProfileService, UserProfileService>();
services.AddTransient <IApiLogService, ApiLogService>();
services.AddTransient <ITodoService, ToDoService>();
services.AddTransient <IMessageService, MessageService>();
// DB Creation and Seeding
services.AddTransient <IDatabaseInitializer, DatabaseInitializer>();
//Automapper to map DTO to Models https://www.c-sharpcorner.com/UploadFile/1492b1/crud-operations-using-automapper-in-mvc-application/
var automapperConfig = new MapperConfiguration(configuration =>
{
configuration.AddProfile(new MappingProfile());
});
var autoMapper = automapperConfig.CreateMapper();
services.AddSingleton(autoMapper);
}
protected virtual IBuildPlan buildPlan(Type pluginType, Policies policies)
{
try
{
policies.Apply(pluginType, this);
var builderSource = ToBuilder(pluginType, policies);
return new BuildPlan(pluginType, this, builderSource, policies, Interceptors);
}
catch (StructureMapException e)
{
e.Push("Attempting to create a BuildPlan for " + toDescription(pluginType));
throw;
}
catch (Exception e)
{
throw new StructureMapBuildPlanException(
"Error while trying to create the BuildPlan for {0}.\nPlease check the inner exception".ToFormat(
toDescription(pluginType)), e);
}
}
public async Task <Dictionary <string, GlobalVersion> > Calculate(
ServiceFabricApplicationProject project,
VersionNumber currentVersion)
{
var projectHashes = new Dictionary <string, GlobalVersion>();
foreach (var service in project.Services)
{
foreach (var subPackage in service.Value.SubPackages)
{
_log.WriteLine($"Computing hash for Service: {service.Key} - Package: {subPackage.Name}");
var hasher = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
var directory = new DirectoryInfo(subPackage.Path);
IOrderedEnumerable <string> files;
if (subPackage.PackageType == PackageType.Code)
{
if (!service.Value.IsGuestExecutable)
{
files = directory
.GetFiles("*", SearchOption.AllDirectories)
.Where(
x =>
_packageConfig.HashIncludeExtensions.Any(
include =>
x.FullName.EndsWith(include,
StringComparison.CurrentCultureIgnoreCase)))
.Where(
x =>
_packageConfig.HashSpecificExludes.All(
exclude => !x.FullName.ToLowerInvariant()
.Contains(exclude.ToLowerInvariant())))
.Select(x => x.FullName)
.OrderBy(x => x);
}
else
{
files = directory
.GetFiles("*", SearchOption.AllDirectories)
.Where(
x =>
_packageConfig.HashSpecificExludes.All(
exclude => !x.FullName.ToLowerInvariant()
.Contains(exclude.ToLowerInvariant())))
.Select(x => x.FullName)
.OrderBy(x => x);
}
}
else
{
files = directory
.GetFiles("*", SearchOption.AllDirectories)
.Select(x => x.FullName)
.OrderBy(x => x);
}
foreach (var data in files.Select(File.ReadAllBytes))
{
hasher.AppendData(data);
}
var externalIncludes = _packageConfig
.ExternalIncludes
.Where(x => x
.ApplicationTypeName.Equals(project.ApplicationTypeName,
StringComparison.CurrentCultureIgnoreCase))
.Where(x => x
.ServiceManifestName.Equals(service.Value.ServiceName,
StringComparison.CurrentCultureIgnoreCase))
.Where(x => x
.PackageName.Equals(subPackage.Name,
StringComparison.CurrentCultureIgnoreCase))
.OrderBy(x => x.SourceFileName);
foreach (var externalFile in externalIncludes)
{
var file = await _fileHandler
.GetFileAsBytesAsync(externalFile.SourceFileName)
.ConfigureAwait(false);
if (!file.IsSuccessful)
{
throw new IOException("Failed to get external file from storage");
}
hasher.AppendData(file.ResponseContent);
}
var finalHash = hasher.GetHashAndReset();
var hash = BitConverter.ToString(finalHash).Replace("-", "").ToLowerInvariant();
var packageVersion = new GlobalVersion
{
Hash = hash,
VersionType = VersionType.ServicePackage,
ParentRef = $"{project.ApplicationTypeName}-{service.Key}",
PackageType = subPackage.PackageType
};
projectHashes.Add($"{project.ApplicationTypeName}-{service.Key}-{subPackage.Name}", packageVersion);
}
var serviceManifest = _serviceManifestLoader.Load(service.Value.SourceServiceManifestPath);
_manifestHandler.SetServiceEndpoints(serviceManifest, project.ApplicationTypeName, service.Value.ServiceName);
using (var serviceManifestStream = new MemoryStream())
{
_serviceManifestLoader.Save(serviceManifest, serviceManifestStream);
var serviceVersion = new GlobalVersion
{
VersionType = VersionType.Service,
ParentRef = project.ApplicationTypeName,
Hash = HashStream(serviceManifestStream)
};
projectHashes.Add($"{project.ApplicationTypeName}-{service.Key}", serviceVersion);
}
}
var appManifest = _appManifestLoader.Load(project.ApplicationManifestFileFullPath);
_manifestHandler.CleanAppManifest(appManifest);
_handleEndpointCert.SetEndpointCerts(_packageConfig, appManifest, project.ApplicationTypeName);
_handleEnciphermentCert.SetEnciphermentCerts(_packageConfig, appManifest, project.ApplicationTypeName);
var guests = _packageConfig.GuestExecutables.Where(x =>
x.ApplicationTypeName.Equals(project.ApplicationTypeName, StringComparison.CurrentCultureIgnoreCase));
foreach (var guest in guests)
{
var policies = new Policies();
if (guest.GuestRunAs != null)
{
var runAs = new RunAsPolicy
{
UserRef = guest.GuestRunAs.UserName,
CodePackageRef = "Code"
};
var runAsPolicies = new List <RunAsPolicy> {
runAs
};
policies.RunAsPolicy = runAsPolicies;
if (appManifest.Principals == null)
{
appManifest.Principals = new Principals();
}
if (appManifest.Principals.Users == null)
{
appManifest.Principals.Users = new Users();
}
if (appManifest.Principals.Users.User == null)
{
appManifest.Principals.Users.User = new List <User>();
}
if (!appManifest.Principals.Users.User.Any(x =>
x.Name.Equals(guest.GuestRunAs.UserName, StringComparison.CurrentCultureIgnoreCase)))
{
var user = new User
{
Name = guest.GuestRunAs.UserName,
AccountType = guest.GuestRunAs.AccountType
};
appManifest.Principals.Users.User.Add(user);
}
}
var serviceManifestRef = new ServiceManifestRef
{
ServiceManifestName = guest.PackageName,
ServiceManifestVersion = "1.0.0"
};
var serviceImport = new ServiceManifestImport
{
ServiceManifestRef = serviceManifestRef,
ConfigOverrides = new ConfigOverrides(),
Policies = policies
};
appManifest.ServiceManifestImports.Add(serviceImport);
}
using (var appManifestStream = new MemoryStream())
{
_appManifestLoader.Save(appManifest, appManifestStream);
projectHashes.Add(project.ApplicationTypeName, new GlobalVersion
{
VersionType = VersionType.Application,
Version = currentVersion,
Hash = HashStream(appManifestStream)
});
}
return(projectHashes);
}
public override IDependencySource ToBuilder(Type pluginType, Policies policies)
{
throw new NotSupportedException();
}
private void tryCreateBuildPlan(Type pluginType, InstanceRef instanceRef, Policies policies,
ProfileReport report)
{
try
{
instanceRef.Instance.ResolveBuildPlan(pluginType, policies);
}
catch (StructureMapException e)
{
_buildPlanFailureIds.Add(instanceRef.Instance.Id);
e.Instances.Fill(instanceRef.Instance.Id);
report.AddError(pluginType, instanceRef.Instance, e);
}
}
