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); } }