public override void Configure(Container container) { AuthFeature.Init(this, () => new CustomUserSession(), new AuthProvider[] { new CredentialsAuthProvider(), //HTML Form post of UserName/Password credentials new BasicAuthProvider(), //Sign-in with Basic Auth }); container.Register <ICacheClient>(new MemoryCacheClient()); var userRep = new InMemoryAuthRepository(); container.Register <IUserAuthRepository>(userRep); string hash; string salt; new SaltedHash().GetHashAndSaltString(Password, out hash, out salt); userRep.CreateUserAuth(new UserAuth { Id = 1, DisplayName = "DisplayName", Email = "*****@*****.**", UserName = UserName, FirstName = "FirstName", LastName = "LastName", PasswordHash = hash, Salt = salt, }, Password); }
protected void InitTest(IUserAuthRepository userAuthRepository) { new RedisClient().FlushAll(); ((IClearable)userAuthRepository).Clear(); var appsettingsMock = new Mock <IResourceManager>(); var appSettings = appsettingsMock.Object; AuthFeature.Init(null, null, new IAuthProvider[] { new CredentialsAuthProvider(), new BasicAuthProvider(), new FacebookAuthProvider(appSettings), new TwitterAuthProvider(appSettings) }); mockService = new Mock <IServiceBase>(); mockService.Expect(x => x.TryResolve <IUserAuthRepository>()).Returns(userAuthRepository); requestContext = new MockRequestContext(); mockService.Expect(x => x.RequestContext).Returns(requestContext); service = mockService.Object; registrationDto = new Registration { UserName = "******", Password = "******", Email = "*****@*****.**", DisplayName = "DisplayName", FirstName = "FirstName", LastName = "LastName", }; }
public override void Configure(Container container) { SetConfig(new HostConfig { DebugMode = true }); var authFeature = new AuthFeature( () => new AuthUserSession(), new IAuthProvider[] { new JwtAuthProviderReader(AppSettings) }); var openIdDiscoveryUrl = "https://server.example.com/open_id_discovery_doc"; var stubClient = new JsonHttpClient(); stubClient.ResultsFilter = (responseType, httpMethod, requestUri, request) => { if (requestUri == openIdDiscoveryUrl) { return(File.ReadAllText("content/sample_openid_discovery_document.json").FromJson <OpenIdDiscoveryDocument>()); } if (requestUri == "https://server.example.com/jwks.json") { return(File.ReadAllText("content/expected_jwks_RS512.json").FromJson <JsonWebKeySetResponse>()); } return(null); }; authFeature.RegisterPlugins.Add(new JwksFeature() { OpenIdDiscoveryUrl = openIdDiscoveryUrl, JwksClient = stubClient }); Plugins.Add(authFeature); }
//Configure ServiceStack Authentication and CustomUserSession private void ConfigureAuth(Funq.Container container) { Routes .Add <Auth>("/auth") .Add <Auth>("/auth/{provider}") .Add <Registration>("/register"); var appSettings = new AppSettings(); AuthFeature.Init(this, () => new CustomUserSession(), new IAuthProvider[] { new CredentialsAuthProvider(appSettings), new FacebookAuthProvider(appSettings), new TwitterAuthProvider(appSettings), new BasicAuthProvider(appSettings), }); RegistrationFeature.Init(this); container.Register <IUserAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>())); var authRepo = (OrmLiteAuthRepository)container.Resolve <IUserAuthRepository>(); if (new AppSettings().Get("Recr eateTables", true)) { authRepo.DropAndReCreateTables(); } else { authRepo.CreateMissingTables(); } }
public void Register(IAppHost appHost, AuthFeature feature) { var isHmac = HmacAlgorithms.ContainsKey(HashAlgorithm); var isRsa = RsaSignAlgorithms.ContainsKey(HashAlgorithm); if (!isHmac && !isRsa) { throw new NotSupportedException("Invalid algoritm: " + HashAlgorithm); } if (isHmac && AuthKey == null) { throw new ArgumentNullException("AuthKey", "An AuthKey is Required to use JWT, e.g: new JwtAuthProvider { AuthKey = AesUtils.CreateKey() }"); } else if (isRsa && PrivateKey == null && PublicKey == null) { throw new ArgumentNullException("PrivateKey", "PrivateKey is Required to use JWT with " + HashAlgorithm); } if (KeyId == null) { KeyId = GetKeyId(); } foreach (var registerService in ServiceRoutes) { appHost.RegisterService(registerService.Key, registerService.Value); } feature.AuthResponseDecorator = AuthenticateResponseDecorator; }
public void Register(IAppHost appHost, AuthFeature feature) { var authRepo = HostContext.AppHost.GetAuthRepository(); if (authRepo == null) { throw new NotSupportedException("ApiKeyAuthProvider requires a registered IAuthRepository"); } if (!(authRepo is IManageApiKeys apiRepo)) { throw new NotSupportedException(authRepo.GetType().Name + " does not implement IManageApiKeys"); } foreach (var registerService in ServiceRoutes) { appHost.RegisterService(registerService.Key, registerService.Value); } feature.AuthEvents.Add(new ApiKeyAuthEvents(this)); if (InitSchema) { using (apiRepo as IDisposable) { apiRepo.InitApiKeySchema(); } } }
public override void Configure(Container container) { AuthFeature.Init(this, () => new CustomUserSession(), new AuthConfig[] { new CredentialsAuthConfig(), //HTML Form post of UserName/Password credentials new BasicAuthConfig(), //Sign-in with Basic Auth }); container.Register <ICacheClient>(new MemoryCacheClient()); container.Register <IUserAuthRepository>(new InMemoryAuthRepository()); }
public void Register(IAppHost appHost, AuthFeature authFeature) { if (!OverrideHtmlRedirect) { return; } // defaults: https://github.com/aspnet/Security/blob/master/src/Microsoft.AspNetCore.Authentication.Cookies/CookieAuthenticationDefaults.cs authFeature.HtmlRedirect = "~/Account/Login"; authFeature.HtmlRedirectReturnParam = "ReturnUrl"; authFeature.HtmlRedirectReturnPathOnly = true; }
public override void Configure(Funq.Container container) { SetConfig(new EndpointHostConfig { DebugMode = false, GlobalResponseHeaders = { { "Access-Control-Allow-Origin", "*" }, { "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" } }, EnableFeatures = ServiceStack.ServiceHost.Feature.All, ServiceStackHandlerFactoryPath = "api" }); ServiceStack.Text.JsConfig.EmitCamelCaseNames = true; var appSettings = new AppSettings(); AppConfig = new AppConfig(appSettings); container.Register(AppConfig); container.Register <ICacheClient>(new MemoryCacheClient()); AdzCredenticalsProvider authProvider = new AdzCredenticalsProvider(); Plugins.Add(new SessionFeature()); AuthFeature authFeature = new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { authProvider, new BasicAuthProvider() }); Plugins.Add(authFeature); //Plugins.Add(new RegistrationFeature()); dbFactory = GetDbConnectionFromConfig(); container.Register <IDbConnectionFactory>(dbFactory); DatabaseConnection = dbFactory.OpenDbConnection(); container.Register(c => dbFactory.OpenDbConnection()).ReusedWithin(Funq.ReuseScope.Container); Helper.Common.ORMCreateTableOnInit(DatabaseConnection, "admin"); var userRep = new ABORMLiteAuthRepository(dbFactory); container.Register <IAuthProvider>(authProvider); container.Register <IUserAuthRepository>(userRep); }
private void ConfigureAuthentication() { var authProviders = new IAuthProvider[] { new ServiceStackCredentialsAuthAdapter(this.unityContainer) }; var authFeature = new AuthFeature(() => new AuthUserSession(), authProviders) { IncludeAssignRoleServices = false }; this.Plugins.Add(authFeature); }
public override void Configure(Container container) { var db = new FakeDataStore(); container.Register <IDataStore>(c => db).ReusedWithin(ReuseScope.Container); JsConfig.ExcludeTypeInfo = true; var auth = new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { new RestivalAuthProvider(db) }) { HtmlRedirect = null }; Plugins.Add(auth); }
public PMSApplication(TestCaseHeaderData headerData, string userName = "", string password = "") { executioner = TestExecutionerPool.GetTestExecutioner(headerData, userName, password, landingPage); if (!executioner.PoolState.WasAlreadyInPool) { executioner.NavigateTo(loginURL, "Navigate to Patitnet management system's login page"); if (!(string.IsNullOrEmpty(userName) && string.IsNullOrEmpty(password))) { this.IsAuthenticated = AuthFeature.LoginToPMS(userName, password); } } }
public override void Configure(Container container) { //Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { container.Resolve<IRenewablesAuthProvider>() })); var authFeature = new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { new CustomCredentialsAuthProvider(container.Resolve <IClientRepository>(), container.Resolve <IMembershipProvider>()), new BasicAuthProvider() }); authFeature.IncludeAssignRoleServices = false; Plugins.Add(authFeature); container.Register <ICacheClient>(new MemoryCacheClient()); }
public void Register(IAppHost appHost, AuthFeature authFeature) { if (AutoSignInSessions) { ((AppHostBase)appHost).BeforeNextMiddleware = SignInAuthenticatedSessions; } if (OverrideHtmlRedirect) { // defaults: https://github.com/aspnet/Security/blob/master/src/Microsoft.AspNetCore.Authentication.Cookies/CookieAuthenticationDefaults.cs authFeature.HtmlRedirect = "~/Account/Login"; authFeature.HtmlRedirectReturnParam = "ReturnUrl"; authFeature.HtmlRedirectReturnPathOnly = true; } }
public override void Configure(Container container) { container.Register <IUserAuthRepository>(new InMemoryAuthRepository()); var authFeature = new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { new JwtAuthProvider { PrivateKeyXml = AppSettings.Get <string>("jwt.RS512.PrivateKeyXml"), FallbackPublicKeys = AppSettings.Get <List <string> >("jwt.RS512.FallbackKeys").Select(x => x.ToPublicRSAParameters()).ToList(), HashAlgorithm = "RS512" } }); authFeature.RegisterPlugins.Add(new JwksFeature()); Plugins.Add(authFeature); }
public override void Configure(Container container) { container.Register <IUserAuthRepository>(new InMemoryAuthRepository()); var authFeature = new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { new JwtAuthProvider { PrivateKeyXml = AppSettings.Get <string>("jwt.RS256.PrivateKeyXml"), HashAlgorithm = "RS256", Issuer = "https://server.example.com" } }); authFeature.RegisterPlugins.Add(new JwksFeature()); Plugins.Add(authFeature); }
public void Register(IAppHost appHost, AuthFeature feature) { var authRepo = appHost.TryResolve <IAuthRepository>().AsUserAuthRepository(appHost); var apiRepo = authRepo as IManageApiKeys; if (apiRepo == null) { throw new NotSupportedException(apiRepo.GetType().Name + " does not implement IManageApiKeys"); } feature.AuthEvents.Add(new ApiKeyAuthEvents(this)); if (InitSchema) { apiRepo.InitApiKeySchema(); } }
public static void Configure(ServiceStackHost appHost, Container container) { var appSettings = new AppSettings(); var auth = new AuthFeature(() => new CustomUserSession(), new IAuthProvider[] { new CustomBasicAuthProvider(), new CredentialsAuthProvider(appSettings) { SessionExpiry = TimeSpan.FromMinutes(30) } }, "/login") { GenerateNewSessionCookiesOnAuthentication = false, }; appHost.Plugins.Add(auth); IUserAuthRepository authRepository = new InMemoryAuthRepository(); ICacheClient cacheClient = new MemoryCacheClient(); var testUser = authRepository.CreateUserAuth(new UserAuth { Email = "*****@*****.**" }, "a"); //IoC registrations container.Register(cacheClient); container.Register(authRepository); var hostConfig = new HostConfig { #if DEBUG || STAGING || UAT DebugMode = true, #endif AppendUtf8CharsetOnContentTypes = new HashSet <string> { MimeTypes.Csv }, }; appHost.SetConfig(hostConfig); }
public override void Register(IAppHost appHost, AuthFeature feature) { base.Register(appHost, feature); var manageApiKeys = HostContext.AppHost.AssertManageApiKeysAsync(); using (manageApiKeys as IDisposable) { if (InitSchema) { manageApiKeys.InitApiKeySchema(); } } appHost.RegisterServices(ServiceRoutes); feature.AuthEvents.Add(new ApiKeyAuthEvents(this)); }
public void Register(IAppHost appHost, AuthFeature feature) { feature.AuthEvents.Add(new ApiKeyAuthEvents(this)); if (InitSchema) { var dbFactory = appHost.TryResolve <IDbConnectionFactory>(); if (dbFactory == null) { throw new NotSupportedException("ApiKeyAuthProvider requires a registered OrmLite IDbConnectionFactory"); } using (var db = dbFactory.OpenDbConnection()) { db.CreateTableIfNotExists <ApiKey>(); } } }
public static void Initialize(Settings settings) { Settings = settings; JWTProvider = new JwtAuthProvider() { AuthKeyBase64 = Settings.Auth.SigningKey, ExpireTokensIn = TimeSpan.FromMinutes(Settings.Auth.TokenValidityMinutes), CreatePayloadFilter = CreatePayload, PopulateSessionFilter = PopulateSession, RequireSecureConnection = false }; AuthFeature = new AuthFeature( () => new UserSession(), new[] { JWTProvider }) { HtmlRedirect = null, IncludeAssignRoleServices = false }; }
public PMSApplication(string testNumber, string testName = "", string testDescription = "", string testFamily = "", string userName = "", string password = "") { TestCaseHeaderData tcHeader = new TestCaseHeaderData() { TestName = string.Format("{0}_{1}", testNumber, testName.Replace(" ", "_")), TestNumber = testNumber, TestDescription = testDescription }; executioner = TestExecutionerPool.GetTestExecutioner(tcHeader, userName, password, landingPage); if (!executioner.PoolState.WasAlreadyInPool) { executioner.NavigateTo(loginURL, "Navigate to Patitnet management system's login page"); if (!(string.IsNullOrEmpty(userName) && string.IsNullOrEmpty(password))) { this.IsAuthenticated = AuthFeature.LoginToPMS(userName, password); } } }
public override void Configure(Funq.Container container) { Routes .Add <Hello>("/hello") .Add <Hello>("/hello/{Name}"); helloService = container.Resolve <HelloService>(); AuthFeature authFeature = new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { new BasicAuthProvider(), new TwitterAuthProvider(new AppSettings()), }); //authFeature.HtmlRedirect Plugins.Add(authFeature); MemoryCacheClient memoryCacheClient = new MemoryCacheClient(); container.Register <ICacheClient>(memoryCacheClient); var userRepository = new InMemoryAuthRepository(); container.Register <IUserAuthRepository>(userRepository); string hash; string salt; string password = "******"; new SaltedHash().GetHashAndSaltString(password, out hash, out salt); userRepository.CreateUserAuth( new UserAuth { Id = 1, DisplayName = "JoeUser", Email = "*****@*****.**", UserName = "******", FirstName = "Joe", LastName = "User", PasswordHash = hash, Salt = salt, }, password); //IHttpResult authenticationRequired = helloService.AuthenticationRequired(); // ???? }
public override void Configure(Container container) { var authFeature = new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { new CredentialsAuthProvider(AppSettings), new AzureAuthenticationProvider(new TestAzureGraphService()) { } }); Plugins.Add(authFeature); container.Register <IDbConnectionFactory>( new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider)); container.Register <IApplicationRegistryService>( c => new OrmLiteMultiTenantApplicationRegistryService(c.Resolve <IDbConnectionFactory>())); container.Register <IAuthRepository>( c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>())); AfterInitCallbacks.Add(appHost => { var authRepo = appHost.TryResolve <IAuthRepository>(); authRepo.InitSchema(); var regService = appHost.TryResolve <IApplicationRegistryService>(); regService.InitSchema(); regService.RegisterApplication(new ApplicationRegistration { ClientId = "clientid", ClientSecret = "clientsecret", DirectoryName = "foodomain.com" }); }); }
public virtual void Register(IAppHost appHost, AuthFeature feature) { RestoreSessionFromState ??= appHost.Config.UseSameSiteCookies == true; }
public override void Configure(Funq.Container container) { var host = ConfigurationManager.AppSettings.Get("PaypalWebsiteURL"); SetConfig(new EndpointHostConfig { DebugMode = false, // Debugmode for stacktrace GlobalResponseHeaders = { { "Access-Control-Allow-Origin", "*" }, { "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" } }, //EnableFeatures = Feature.All.Remove(GetDisabledFeatures()), EnableFeatures = ServiceStack.ServiceHost.Feature.All, //RestrictAllCookiesToDomain = "www.photobookmart.com" //ServiceStackHandlerFactoryPath = "api", //AppendUtf8CharsetOnContentTypes = new HashSet<string> { ContentType.Html }, }); //Set JSON web services to return idiomatic JSON camelCase properties ServiceStack.Text.JsConfig.EmitCamelCaseNames = false; //Register a external dependency-free //container.Register<ICacheClient>(new MemoryCacheClient()); /* TODO:... * var redis_host = ConfigurationManager.AppSettings.Get("RedisHost"); * var redis_db = long.Parse(ConfigurationManager.AppSettings.Get("RedisDBVersion")); * var pooled_redis = new PooledRedisClientManager(redis_db, redis_host); * pooled_redis.NamespacePrefix = System.Reflection.Assembly.GetExecutingAssembly().FullName; * container.Register<IRedisClientsManager>(c => pooled_redis); * container.Register<ICacheClient>(c => * (ICacheClient)c.Resolve<IRedisClientsManager>() * .GetCacheClient()) * .ReusedWithin(Funq.ReuseScope.None);*/ //Enable Authentication an Registration VMCCredenticalsProvider authProvider = new VMCCredenticalsProvider(); Plugins.Add(new SessionFeature()); AuthFeature authFeature = new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { authProvider, new BasicAuthProvider() }); //authFeature.ServiceRoutes.Clear(); // we clear all routes Plugins.Add(authFeature); Plugins.Add(new RegistrationFeature()); //Create a DB Factory configured to access the UserAuth SQL Server DB dbFactory = GetDbConnectionFromConfig(); //container.Register(c => GetDbConnectionFromConfig()).ReusedWithin(Funq.ReuseScope.Container); //var dbConnection = container.Resolve<OrmLiteConnectionFactory>(); container.Register <IDbConnectionFactory>(dbFactory); //container.Register(c => GetDbConnectionFromConfig()).ReusedWithin(Funq.ReuseScope.Request); // register db connection //container.Register(c => dbFactory.OpenDbConnection()).ReusedWithin(Funq.ReuseScope.Container); DatabaseConnection = dbFactory.OpenDbConnection(); container.Register(c => dbFactory.OpenDbConnection()).ReusedWithin(Funq.ReuseScope.Container); //container.Register<IDbConnection>(DatabaseConnection); // caching - TODO: later must change to ORMLiteCache //container.RegisterAs<OrmLiteCacheClient, ICacheClient>(); //Create 'CacheEntry' RDBMS table if it doesn't exist already //container.Resolve<ICacheClient>().InitSchema(); // end of caching register // create tables ModelBase.InitDbTable(ConfigurationManager.AppSettings.Get("AdminUserNames"), true, true); //container.RegisterAutoWired<IDbConnection>(); //container.Register<IDbConnectionFactory>(dbConnection); // Register ORM Lite Authentication Repository with our Authentication var userRep = new ABORMLiteAuthRepository(dbFactory); container.Register <IAuthProvider>(authProvider); container.Register <IUserAuthRepository>(userRep); //Configure Custom User Defined REST Paths for your services ConfigureServiceRoutes(); //Set MVC to use the same Funq IOC as ServiceStack ControllerBuilder.Current.SetControllerFactory(new FunqControllerFactory(container)); //ServiceStackController.CatchAllController = reqCtx => container.TryResolve<HomeController>(); }
public override void Configure(Container container) { this.ServiceExceptionHandlers.Add((httpReq, request, exception) => { httpReq.Items["__exception"] = exception; return(new HttpError { Status = exception.ToStatusCode() }); }); //Handle Unhandled Exceptions occurring outside of Services //E.g. Exceptions during Request binding or in filters: this.UncaughtExceptionHandlers.Add((httpReq, res, operationName, exception) => { if (res.StatusCode == 200) { res.StatusCode = exception.ToStatusCode(); } res.EndRequest(); }); Plugins.Add(new ValidationFeature()); var hostConfig = new HostConfig { IgnoreFormatsInMetadata = new HashSet <string> { "xml", "csv", "jsv" }, DefaultContentType = MimeTypes.Json, }; hostConfig.MapExceptionToStatusCode.Add(typeof(CryptographicException), 401); SetConfig(hostConfig); this.Plugins.Add(new PostmanFeature() { DefaultLabelFmt = new List <string> { "route", " - ", "type:english" }, }); this.Plugins.Add(new CorsFeature(allowedHeaders: "Content-Type,Authorization,x-client-version")); var privateKey = _settings.GetString("Security:PrivateKeyXml");//Получение закрытого ассиметричного ключа из конфига //Для генерации ключей //var keys = RsaUtils.CreatePublicAndPrivateKeyPair(RsaKeyLengths.Bit4096); var requireSecureConnectionStr = _settings.GetString("Security:RequireSecureConnection"); bool.TryParse(requireSecureConnectionStr, out var requireSecureConnection); var jwtprovider = new JwtAuthProvider(_settings) { RequireSecureConnection = requireSecureConnection,//требуется защищённое соединение HashAlgorithm = "RS512", PrivateKeyXml = privateKey, EncryptPayload = true, //шифрование токена ExpireTokensInDays = 1, //срок жизни токена ExpireRefreshTokensIn = TimeSpan.FromDays(30), AllowInQueryString = true, //токен можно передавать в параметрах как ?ss-tok AllowInFormData = true, //токен можно передавать в теле как ss-tok PopulateSessionFilter = (session, o, arg3) => { if (o.TryGetValue("session", out var sessionid)) { if (session is AuthUserSession ses) { ses.Id = sessionid; } } } }; if (_env.IsDevelopment()) //при отладке { jwtprovider.RequireSecureConnection = false; //выключить требование защищённого соединения } jwtprovider.ServiceRoutes?.Clear();//Отключаю стандартные методы var authFeature = new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { jwtprovider, }) { IncludeAssignRoleServices = false, IncludeAuthMetadataProvider = false, IncludeRegistrationService = false, }; authFeature.ServiceRoutes.Clear();//Отключаю стандартные методы Plugins.Add(authFeature); Plugins.Add(new OpenApiFeature { UseBearerSecurity = true }); Plugins.Add(new SwaggerFeature { UseCamelCaseModelPropertyNames = true, UseBootstrapTheme = true }); } }
public void Register(IAppHost appHost, AuthFeature feature) { var authRepo = HostContext.AppHost.GetAuthRepository(); if (authRepo == null) throw new NotSupportedException("ApiKeyAuthProvider requires a registered IAuthRepository"); var apiRepo = authRepo as IManageApiKeys; if (apiRepo == null) throw new NotSupportedException(authRepo.GetType().Name + " does not implement IManageApiKeys"); foreach (var registerService in ServiceRoutes) { appHost.RegisterService(registerService.Key, registerService.Value); } feature.AuthEvents.Add(new ApiKeyAuthEvents(this)); if (InitSchema) { using (apiRepo as IDisposable) { apiRepo.InitApiKeySchema(); } } }
// Configure your AppHost with the necessary configuration and dependencies your App needs public override void Configure(Container container) { SetConfig(new HostConfig { DefaultRedirectPath = "/index.html", DebugMode = AppSettings.Get(nameof(HostConfig.DebugMode), false) }); JsConfig.IncludeNullValues = false; JsConfig.ExcludeTypeInfo = true; JsConfig.DateHandler = DateHandler.ISO8601; JsConfig.TextCase = TextCase.PascalCase; JsConfig.TimeSpanHandler = TimeSpanHandler.StandardFormat; #region Database var connString = AppSettings.Get("dbConnectionString", ""); if (connString == "%%CONN_STR%%") { connString = AppSettings.Get("dbConnectionStringDev", ""); } var dbFactory = new OrmLiteConnectionFactory(connString, SqlServer2008Dialect.Provider); container.Register <IDbConnectionFactory>(dbFactory); OrmLiteConfig.StringFilter = s => s.Trim(); #endregion #region Plugins Plugins.Add(new CorsFeature( allowedHeaders: "Content-Type, Allow, Authorization")); Plugins.Add(new OpenApiFeature() { ApiDeclarationFilter = declaration => { declaration.Info.Title = "Badges Molex Net Core"; //declaration.Info.Contact = new ServiceStack.Api.OpenApi.Specification.OpenApiContact() //{ // Email = "*****@*****.**", // Name = "Alfredo Pacheco" //}; declaration.Info.Description = ""; }, OperationFilter = (verb, op) => { switch (verb) { case "POST": op.Parameters.RemoveAll(p => p.Name == "Id"); op.Parameters.RemoveAll(p => p.Name == "RowVersion"); break; default: break; } op.Parameters.RemoveAll(p => p.Name == "EntityName"); op.Parameters.RemoveAll(p => p.Name == "EF_State"); } }); Plugins.Add(new AutoQueryFeature { //MaxLimit = 100 }); Plugins.Add(new RequestLogsFeature()); Plugins.Add(new AdminFeature()); // var rollbarSettings = AppSettings.Get<RollbarSettings>("RollbarPluginSettings"); // Plugins.Add(new RollbarLoggerPlugin // { // ApiKey = rollbarSettings.ApiKey, // Enabled = rollbarSettings.Enabled, // EnableErrorTracking = rollbarSettings.EnableErrorTracking, // EnableRequestBodyTracking = rollbarSettings.EnableRequestBodyTracking, // EnableResponseTracking = rollbarSettings.EnableResponseTracking, // EnableSessionTracking = rollbarSettings.EnableSessionTracking, // Environment = rollbarSettings.Environment, // // HideRequestBodyForRequestDtoTypes = new List<Type>(), // // ExcludeRequestDtoTypes = new List<Type> // // { // // // Might have to exclude the Swagger requests to get the two to play nicely // // typeof(RollbarLogConfigRequest), // // typeof(SwaggerResource), // // typeof(SwaggerApiDeclaration) // // }, // RequiredRoles = rollbarSettings.RequiredRoles, // SkipLogging = IsRequestSkippedDuringRequestLogging // }); #endregion #region Auth var authProviders = new List <IAuthProvider> { new JwtAuthProvider(AppSettings) { RequireSecureConnection = false, AllowInQueryString = true }, new CredentialsAuthProvider() }; var authFeature = new AuthFeature(SessionFactory, authProviders.ToArray()); Plugins.Add(authFeature); //var authRepo = new OrmLiteAuthRepository(dbFactory); //container.Register<IUserAuthRepository>(authRepo); //authRepo.InitSchema(); //Plugins.Add(new RegistrationFeature()); //var admin = authRepo.GetUserAuthByUserName("admin"); //if (admin == null) // authRepo.CreateUserAuth(new UserAuth // { // UserName = "******", // Roles = new List<string> { RoleNames.Admin } // }, "admin"); #endregion //TODO: //Cache. //Logging. //Batched requests. //Profiler. //Versioning. //stripe.com #region Cache //container.Register<ICacheClient>(new MemoryCacheClient()); #endregion #region App //container.Register(c => dbFactory.Open()); //container.Register(c => c.Resolve<IDbConnectionFactory>().OpenDbConnection()).ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <RevisionLogic>().ReusedWithin(ReuseScope.Request); MailgunService.AppSettings = AppSettings; container.Register <IEmailService>(i => new MailgunService()).ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <CatalogLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <CatalogDefinitionLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <FieldLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <CatalogFieldValueLogic>().ReusedWithin(ReuseScope.Request); //This App: ///start:generated:di<<< container.RegisterAutoWired <ActivityLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <ApprovalLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <BadgeLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <EmailLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <AdvancedSortLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <ApplicationTaskLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <FilterDataLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <SortDataLogic>().ReusedWithin(ReuseScope.Request); container.RegisterAutoWired <TokenLogic>().ReusedWithin(ReuseScope.Request); ///end:generated:di<<< #endregion #region Seed Data Sower.Seed(dbFactory); #endregion }
public override void Configure(Container container) { JsConfig.DateHandler = DateHandler.ISO8601; var appSettings = new AppSettings(); ServiceExceptionHandlers.Add((httpReq, request, exception) => { var logger = LogManager.GetLogger(GetType()); logger.Error(exception); return(null); }); container.Register <ICacheClient>(new MemoryCacheClient { FlushOnDispose = false }); JsConfig.AssumeUtc = true; container.RegisterAs <FordereAuthEventHandler, IAuthEvents>(); container.Register <IDbConnectionFactory>( new OrmLiteConnectionFactory( "Server = {0}; Database = {1}; Uid = {2}; Pwd = {3}".Fmt( appSettings.Get("DB.Host"), appSettings.Get("DB.Name"), appSettings.Get("DB.User"), appSettings.Get("DB.Pass")), MySqlDialect.Provider)); container.Register <IUserAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>())); var authProvider = new IAuthProvider[] { new CredentialsAuthProvider(), new JwtAuthProvider(appSettings), }.ToList(); if (appSettings.Get("Debug", false)) { authProvider.Add(new BasicAuthProvider()); } var authFeature = new AuthFeature(() => new FordereAuthUserService(), authProvider.ToArray()); this.Plugins.Add(new RegistrationFeature()); this.Plugins.Add(authFeature); this.Plugins.Add(new RequestLogsFeature { // do not log request bodies of requests containing passwords HideRequestBodyForRequestDtoTypes = new[] { typeof(Authenticate), typeof(Register), typeof(UpdateUserProfileRequest) }, }); if (appSettings.Get("CORS.Enabled", false)) { this.Plugins.Add( new CorsFeature( allowedOrigins: appSettings.GetString("CORS.AllowedOrigins"), allowedMethods: "OPTIONS,GET,POST,PUT,DELETE,PATCH", allowedHeaders: "Content-Type,Authorization,division_id", allowCredentials: true)); } if (appSettings.Get("Debug", false)) { this.Plugins.Add(new PostmanFeature()); this.Plugins.Add(new OpenApiFeature()); } if (appSettings.Get("Debug", false) == false) { this.Plugins.RemoveAll(x => x is MetadataFeature); } this.SetConfig(new HostConfig { // TODO SSH This sets ss-pid/ss-opt to NOT HttpOnly.. is this a security issue? AllowNonHttpOnlyCookies = true, DebugMode = appSettings.Get("Debug", false) }); this.RegisterTypedRequestFilter <ICaptchaRequest>(Filter.Captcha); this.RegisterTypedRequestFilter <EnterMatchAppointmentRequest>(Filter.EnterMatchAppointment); this.RegisterTypedRequestFilter <EnterMatchResultRequest>(Filter.EnterMatchResult); this.RegisterTypedResponseFilter <TeamDto>(Filter.TeamPlayerDetails); PreRequestFilters.Add((httpReq, httpRes) => { if (httpReq.Verb.ToUpper() == "PATCH") { httpReq.UseBufferedStream = true; } }); }
public void Register(IAppHost appHost, AuthFeature feature) { var authRepo = appHost.TryResolve<IAuthRepository>().AsUserAuthRepository(appHost); var apiRepo = authRepo as IManageApiKeys; if (apiRepo == null) throw new NotSupportedException(apiRepo.GetType().Name + " does not implement IManageApiKeys"); foreach (var registerService in ServiceRoutes) { appHost.RegisterService(registerService.Key, registerService.Value); } feature.AuthEvents.Add(new ApiKeyAuthEvents(this)); if (InitSchema) { apiRepo.InitApiKeySchema(); } }
public void PreRegister(AppHostBase appHost, Container container) { var dbFactory = container.TryResolve <IDbConnectionFactory>(); var appSettings = container.TryResolve <IAppSettings>(); if (dbFactory == null || appSettings == null) { return; // missing required dependencies } var authProviders = new List <IAuthProvider>(); authProviders.Add(new CredentialsAuthProvider(appSettings)); authProviders.Add(new BasicAuthProvider(appSettings)); var apiKeyProvider = new ApiKeyAuthProvider(appSettings) { RequireSecureConnection = false, ServiceRoutes = new Dictionary <Type, string[]> { { typeof(GetApiKeysService), new[] { "/auth/apikeys", "/auth/apikeys/{Environment}" } }, { typeof(RegenerateApiKeysService), new [] { "/auth/apikeys/regenerate", "/auth/apikeys/regenerate/{Environment}" } }, } }; authProviders.Add(apiKeyProvider); var privateKeyXml = (appSettings as OrmLiteAppSettings)?.GetOrCreate("PrivateKeyXml", () => { return(RsaUtils.CreatePrivateKeyParams().ToPrivateKeyXml()); }); if (!string.IsNullOrWhiteSpace(privateKeyXml)) { authProviders.Add(new JwtAuthProvider(appSettings) { PrivateKeyXml = privateKeyXml, HashAlgorithm = "RS256", RequireSecureConnection = false, SetBearerTokenOnAuthenticateResponse = true, IncludeJwtInConvertSessionToTokenResponse = true, ServiceRoutes = new Dictionary <Type, string[]> { { typeof(ConvertSessionToTokenService), new[] { "/auth/session-to-token" } }, { typeof(GetAccessTokenService), new[] { "/auth/access-token" } }, } }); } var authRepository = new AppAuthRepository(dbFactory); authRepository.InitSchema(); authRepository.InitApiKeySchema(); appHost.Register <IUserAuthRepository>(authRepository); appHost.Register <IAuthRepository>(authRepository); var authFeature = new AuthFeature(() => new AppUserSession(), authProviders.ToArray()) { IncludeRegistrationService = false, IncludeAssignRoleServices = false, DeleteSessionCookiesOnLogout = true, GenerateNewSessionCookiesOnAuthentication = true, SaveUserNamesInLowerCase = true, ValidateUniqueEmails = true, ValidateUniqueUserNames = true }; authFeature.ServiceRoutes[typeof(AuthenticateService)] = authFeature.ServiceRoutes[typeof(AuthenticateService)].Where(r => !r.Contains("authenticate")).ToArray(); appHost.Plugins.Add(authFeature); var regFeature = new RegistrationFeature { AllowUpdates = false, AtRestPath = "/auth/register" }; appHost.Plugins.Add(regFeature); }
public void Register(IAppHost appHost, AuthFeature feature) { var isHmac = HmacAlgorithms.ContainsKey(HashAlgorithm); var isRsa = RsaSignAlgorithms.ContainsKey(HashAlgorithm); if (!isHmac && !isRsa) throw new NotSupportedException("Invalid algoritm: " + HashAlgorithm); if (isHmac && AuthKey == null) throw new ArgumentNullException("AuthKey", "An AuthKey is Required to use JWT, e.g: new JwtAuthProvider { AuthKey = AesUtils.CreateKey() }"); else if (isRsa && PrivateKey == null && PublicKey == null) throw new ArgumentNullException("PrivateKey", "PrivateKey is Required to use JWT with " + HashAlgorithm); if (KeyId == null) KeyId = GetKeyId(); foreach (var registerService in ServiceRoutes) { appHost.RegisterService(registerService.Key, registerService.Value); } feature.AuthResponseDecorator = AuthenticateResponseDecorator; }