/// <summary> /// Saves the Auth Tokens for this request. Called in OnAuthenticated(). /// Overrideable, the default behaviour is to call IUserAuthRepository.CreateOrMergeAuthSession(). /// </summary> protected virtual void SaveUserAuth(IServiceBase authService, IAuthSession session, IUserAuthRepository authRepo, IOAuthTokens tokens) { if (authRepo == null) return; if (tokens != null) { session.UserAuthId = authRepo.CreateOrMergeAuthSession(session, tokens); } authRepo.LoadUserAuth(session, tokens); foreach (var oAuthToken in session.ProviderOAuthAccess) { var authProvider = AuthService.GetAuthProvider(oAuthToken.Provider); if (authProvider == null) continue; var userAuthProvider = authProvider as OAuthProvider; if (userAuthProvider != null) { userAuthProvider.LoadUserOAuthProvider(session, oAuthToken); } } authRepo.SaveUserAuth(session); var httpRes = authService.RequestContext.Get<IHttpResponse>(); if (httpRes != null) { httpRes.Cookies.AddPermanentCookie(HttpHeaders.XUserAuthId, session.UserAuthId); } OnSaveUserAuth(authService, session); }
public OrderController(IOrderRepository orderRepo, IUserAuthRepository userAuthRepo, ICustomerRepository customerRepo, IOrderLogRepository orderLogRepo, IOrderItemRepository orderItemRepo, IInboundPackRepository inboundRepo, IOutboundRepository outboundRepo, IOutboundItemRepository outbounditemRepo, ISectionRepository sectionRepo, IRMARepository rmaRepo, IRMALogRepository rmalogRepo, IRMAItemRepository rmaitemRepo ) { _orderRepo = orderRepo; _userAuthRepo = userAuthRepo; _customerRepo = customerRepo; _orderLogRepo = orderLogRepo; _orderItemRepo = orderItemRepo; _inboundRepo = inboundRepo; _outboundRepo = outboundRepo; _outbounditemRepo = outbounditemRepo; _sectionRepo = sectionRepo; _rmaRepo = rmaRepo; _rmalogRepo = rmalogRepo; _rmaitemRepo = rmaitemRepo; }
private static void CreateUser(IUserAuthRepository userRepo, IUserAuth user, string password) { string hash; string salt; new SaltedHash().GetHashAndSaltString(password, out hash, out salt); user.Salt = salt; user.PasswordHash = hash; userRepo.CreateUserAuth(user, password); }
public void Can_AutoLogin_whilst_Registering(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var oAuthUserSession = requestContext.ReloadSession(); registrationDto.AutoLogin = true; Register(userAuthRepository, oAuthUserSession, registrationDto); oAuthUserSession = requestContext.ReloadSession(); Assert.That(oAuthUserSession.IsAuthenticated, Is.True); }
public UserAuthController(IUserAuthRepository authRepo ,IStoreRepository storeRepo ,IBrandRepository brandRepo ,ICustomerRepository customerRepo) { _authRepo = authRepo; _storeRepo = storeRepo; _brandRep = brandRepo; _customerRepo = customerRepo; }
public PromotionController(IPromotionRepository promotionRepository ,IStoreRepository storeRepository ,ITagRepository tagRepository ,IResourceService resourceService ,IUserAuthRepository authRepo) { this._promotionRepository = promotionRepository; _storeRepository = storeRepository; _tagRepository = tagRepository; _resourceService = resourceService; _authRepo = authRepo; }
public static RegistrationService GetRegistrationService( AbstractValidator<Registration> validator = null, IUserAuthRepository authRepo=null) { var requestContext = new MockRequestContext(); var service = new RegistrationService { RegistrationValidator = validator ?? new RegistrationValidator { UserAuthRepo = GetStubRepo() }, UserAuthRepo = authRepo ?? GetStubRepo(), RequestContext = requestContext }; return service; }
public bool HasAllRoles(IHttpRequest req, IAuthSession session, IUserAuthRepository userAuthRepo=null) { if (HasAllRoles(session)) return true; session.UpdateFromUserAuthRepo(req, userAuthRepo); if (HasAllRoles(session)) { req.SaveSession(session); return true; } return false; }
public ProductController(IProductRepository productRepository , ISpecialTopicProductRelationRepository specialTopicProductRelationRepository , IPromotionProductRelationRepository promotionProductRelationRepository , IStoreRepository storeRepository , IResourceService resourceService , IUserAuthRepository userAuthRepo) { _productRepository = productRepository; _stprRepository = specialTopicProductRelationRepository; _pprRepository = promotionProductRelationRepository; _storeRepository = storeRepository; _resourceService = resourceService; _userAuthRepo = userAuthRepo; }
public OrderController(IOrderRepository orderRepo, IUserAuthRepository userAuthRepo, ICustomerRepository customerRepo, IOrderLogRepository orderLogRepo, IOrderItemRepository orderItemRepo, IInboundPackRepository inboundRepo) { _orderRepo = orderRepo; _userAuthRepo = userAuthRepo; _customerRepo = customerRepo; _orderLogRepo = orderLogRepo; _orderItemRepo = orderItemRepo; _inboundRepo = inboundRepo; }
public ProductPropertyValueController(ITagRepository tagRepo, ICategoryPropertyRepository tagpropertyRepo, ICategoryPropertyValueRepository tagpropertyvalRepo, IProductPropertyValueRepository prodpropertyvalRepo, IProductPropertyRepository prodpropertyRepo, IProductRepository prodRepo, IUserAuthRepository userauthRepo ) { _tagRepo = tagRepo; _tagpropertyRepo = tagpropertyRepo; _tagpropertyvalueRepo = tagpropertyvalRepo; _prodpropertyRepo = prodpropertyRepo; _prodpropertyvalRepo = prodpropertyvalRepo; _prodRepo = prodRepo; _userauthRepo = userauthRepo; }
public void Connecting_to_facebook_whilst_authenticated_connects_account(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var oAuthUserSession = requestContext.ReloadSession(); oAuthUserSession = RegisterAndLogin(userAuthRepository, oAuthUserSession); LoginWithFacebook(oAuthUserSession); var userAuth = userAuthRepository.GetUserAuthByUserName(registrationDto.UserName); Assert.That(userAuth.UserName, Is.EqualTo(registrationDto.UserName)); var userAuthProviders = userAuthRepository.GetUserOAuthProviders(userAuth.Id.ToString(CultureInfo.InvariantCulture)); Assert.That(userAuthProviders.Count, Is.EqualTo(1)); }
public static RegistrationService GetRegistrationService( AbstractValidator<Registration> validator = null, IUserAuthRepository authRepo=null) { var requestContext = new MockRequestContext(); var userAuthRepository = authRepo ?? GetStubRepo(); var service = new RegistrationService { RegistrationValidator = validator ?? new RegistrationValidator { UserAuthRepo = userAuthRepository }, UserAuthRepo = userAuthRepository, RequestContext = requestContext, }; var appHost = GetAppHost(); appHost.Register(userAuthRepository); service.SetAppHost(appHost); return service; }
private void CreateUser(IUserAuthRepository userRep, int id, string userName, string email, string password, List<string> roles = null, List<string> permissions = null) { string hash; string salt; new SaltedHash().GetHashAndSaltString(password, out hash, out salt); userRep.CreateUserAuth(new UserAuth { Id = id, DisplayName = "DisplayName", Email = email, UserName = userName, FirstName = "FirstName", LastName = "LastName", PasswordHash = hash, Salt = salt, Roles = roles, Permissions = permissions }, password); }
public bool HasAllRoles(IHttpRequest req, IAuthSession session, IUserAuthRepository userAuthRepo=null) { if (HasAllRoles(session)) return true; if (userAuthRepo == null) userAuthRepo = req.TryResolve<IUserAuthRepository>(); if (userAuthRepo == null) return false; var userAuth = userAuthRepo.GetUserAuth(session, null); session.UpdateSession(userAuth); if (HasAllRoles(session)) { req.SaveSession(session); return true; } return false; }
protected void InitTest(IUserAuthRepository userAuthRepository) { try { ((IClearable)userAuthRepository).Clear(); } catch { /*ignore*/ } var appsettingsMock = new Mock<IAppSettings>(); var appSettings = appsettingsMock.Object; new AuthFeature(null, new IAuthProvider[] { new CredentialsAuthProvider(), new BasicAuthProvider(), new FacebookAuthProvider(appSettings), new TwitterAuthProvider(appSettings) }) .Register(null); mockService = new Mock<IServiceBase>(); mockService.Expect(x => x.TryResolve<IAuthRepository>()).Returns(userAuthRepository); requestContext = new BasicRequest { Headers = { {"X-ss-id", SessionExtensions.CreateRandomSessionId() } } }; mockService.Expect(x => x.Request).Returns(requestContext); service = mockService.Object; RegisterDto = new Register { UserName = "******", Password = "******", Email = "*****@*****.**", DisplayName = "DisplayName", FirstName = "FirstName", LastName = "LastName", }; }
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext) { string errorUnAuthorizedDataAccess = "没有授权操作该门店和品牌!"; var currentUser = ServiceLocator.Current.Resolve <IAuthenticationService>().CurrentUserFromHttpContext(HttpContext.Current); if (currentUser == null) { yield return(new ValidationResult(errorUnAuthorizedDataAccess)); } IUserAuthRepository authRepo = ServiceLocator.Current.Resolve <IUserAuthRepository>(); if (currentUser.Role == (int)UserRole.Admin) { yield break; } if (!authRepo.Get(a => a.UserId == currentUser.CustomerId) .Any(a => a.StoreId == 0 || (a.StoreId == this.Store_Id && (a.BrandId == 0 || a.BrandId == this.Brand_Id)))) { yield return(new ValidationResult(errorUnAuthorizedDataAccess)); } }
public void PopulateSession(IUserAuthRepository authRepo, IUserAuth userAuth, CustomUserSession session, string userId) { if (authRepo == null) { return; } var holdSessionId = session.Id; session.PopulateWith(userAuth); //overwrites session.Id session.Id = holdSessionId; session.IsAuthenticated = true; session.UserAuthId = userId; string temp = userId.Substring(userId.IndexOf(CharConstants.COLON) + 1); session.Email = temp.Substring(0, temp.IndexOf(CharConstants.COLON)); session.Uid = (userAuth as User).UserId; session.WhichConsole = userId.Substring(userId.Length - 2); session.Roles.Clear(); session.Permissions.Clear(); }
public void Can_login_with_user_created_CreateUserAuth(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var registrationService = GetRegistrationService(userAuthRepository); var responseObj = registrationService.Post(registrationDto); var httpResult = responseObj as IHttpResult; if (httpResult != null) { Assert.Fail("HttpResult found: " + httpResult.Dump()); } var response = (RegistrationResponse)responseObj; Assert.That(response.UserId, Is.Not.Null); var userAuth = userAuthRepository.GetUserAuth(response.UserId); AssertEqual(userAuth, registrationDto); userAuth = userAuthRepository.GetUserAuthByUserName(registrationDto.UserName); AssertEqual(userAuth, registrationDto); userAuth = userAuthRepository.GetUserAuthByUserName(registrationDto.Email); AssertEqual(userAuth, registrationDto); UserAuth userId; var success = userAuthRepository.TryAuthenticate(registrationDto.UserName, registrationDto.Password, out userId); Assert.That(success, Is.True); Assert.That(userId, Is.Not.Null); success = userAuthRepository.TryAuthenticate(registrationDto.Email, registrationDto.Password, out userId); Assert.That(success, Is.True); Assert.That(userId, Is.Not.Null); success = userAuthRepository.TryAuthenticate(registrationDto.UserName, "Bad Password", out userId); Assert.That(success, Is.False); Assert.That(userId, Is.Null); }
public static RegisterService GetRegistrationService( AbstractValidator<Register> validator = null, IUserAuthRepository authRepo = null, string contentType = null) { var requestContext = new MockRequestContext(); if (contentType != null) { requestContext.ResponseContentType = contentType; } var userAuthRepository = authRepo ?? GetStubRepo(); var service = new RegisterService { RegistrationValidator = validator ?? new RegistrationValidator { UserAuthRepo = userAuthRepository }, AuthRepo = userAuthRepository, RequestContext = requestContext, }; HostContext.Container.Register(userAuthRepository); return service; }
public void Does_persist_FacebookOAuth(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var serviceTokens = MockAuthHttpGateway.Tokens = facebookGatewayTokens; var oAuthUserSession = requestContext.ReloadSession(); var authInfo = new Dictionary<string, string> { }; var facebookAuth = GetFacebookAuthProvider(); facebookAuth.OnAuthenticated(service, oAuthUserSession, facebookAuthTokens, authInfo); oAuthUserSession = requestContext.ReloadSession(); Assert.That(oAuthUserSession.FacebookUserId, Is.EqualTo(serviceTokens.UserId)); Assert.That(oAuthUserSession.UserAuthId, Is.Not.Null); var userAuth = userAuthRepository.GetUserAuth(oAuthUserSession.UserAuthId); Assert.That(userAuth.Id.ToString(CultureInfo.InvariantCulture), Is.EqualTo(oAuthUserSession.UserAuthId)); Assert.That(userAuth.DisplayName, Is.EqualTo(serviceTokens.DisplayName)); Assert.That(userAuth.FirstName, Is.EqualTo(serviceTokens.FirstName)); Assert.That(userAuth.LastName, Is.EqualTo(serviceTokens.LastName)); Assert.That(userAuth.PrimaryEmail, Is.EqualTo(serviceTokens.Email)); var authProviders = userAuthRepository.GetUserAuthDetails(oAuthUserSession.UserAuthId); Assert.That(authProviders.Count, Is.EqualTo(1)); var authProvider = authProviders[0]; Assert.That(authProvider.UserAuthId, Is.EqualTo(userAuth.Id)); Assert.That(authProvider.DisplayName, Is.EqualTo(serviceTokens.DisplayName)); Assert.That(authProvider.FirstName, Is.EqualTo(serviceTokens.FirstName)); Assert.That(authProvider.LastName, Is.EqualTo(serviceTokens.LastName)); Assert.That(authProvider.Email, Is.EqualTo(serviceTokens.Email)); Assert.That(authProvider.RequestToken, Is.Null); Assert.That(authProvider.RequestTokenSecret, Is.Null); Assert.That(authProvider.AccessToken, Is.Null); Assert.That(authProvider.AccessTokenSecret, Is.EqualTo(facebookAuthTokens.AccessTokenSecret)); Console.WriteLine(authProviders.Dump()); }
private void AddSeedUsers(IUserAuthRepository authRepo) { // if (authRepo.GetUserAuthByUserName("*****@*****.**") == null) // { // var testUser = authRepo.CreateUserAuth(new UserAuth // { // DisplayName = "Test User", // Email = "*****@*****.**", // FirstName = "Test", // LastName = "User", // }, "p@55wOrd"); // } // if (authRepo.GetUserAuthByUserName("*****@*****.**") == null) // { // var roleUser = authRepo.CreateUserAuth(new UserAuth // { // DisplayName = "Test Manager", // Email = "*****@*****.**", // FirstName = "Test", // LastName = "Manager", // }, "p@55wOrd"); // authRepo.AssignRoles(roleUser, roles: new[] { "Manager" }); // } if (authRepo.GetUserAuthByUserName("*****@*****.**") == null) { var roleUser = authRepo.CreateUserAuth(new UserAuth { DisplayName = "Admin User", Email = "*****@*****.**", FirstName = "Admin", LastName = "User", UserName = "******" }, "admin"); authRepo.AssignRoles(roleUser, roles: new[] { "Admin" }); } }
public void Does_merge_FacebookOAuth_TwitterOAuth(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var serviceTokensFb = MockAuthHttpGateway.Tokens = facebookGatewayTokens; var oAuthUserSession = requestContext.ReloadSession(); var facebookAuth = GetFacebookAuthProvider(); facebookAuth.OnAuthenticated(service, oAuthUserSession, facebookAuthTokens, new Dictionary<string, string>()); oAuthUserSession = requestContext.ReloadSession(); var serviceTokensTw = MockAuthHttpGateway.Tokens = twitterGatewayTokens; var authInfo = new Dictionary<string, string> { {"user_id", "133371690876022785"}, {"screen_name", "demisbellot"}, }; var twitterAuth = GetTwitterAuthProvider(); twitterAuth.OnAuthenticated(service, oAuthUserSession, twitterAuthTokens, authInfo); oAuthUserSession = requestContext.ReloadSession(); Assert.That(oAuthUserSession.TwitterUserId, Is.EqualTo(authInfo["user_id"])); Assert.That(oAuthUserSession.TwitterScreenName, Is.EqualTo(authInfo["screen_name"])); var userAuth = userAuthRepository.GetUserAuth(oAuthUserSession.UserAuthId); Assert.That(userAuth.Id.ToString(CultureInfo.InvariantCulture), Is.EqualTo(oAuthUserSession.UserAuthId)); Assert.That(userAuth.DisplayName, Is.EqualTo(serviceTokensTw.DisplayName)); Assert.That(userAuth.FirstName, Is.EqualTo(serviceTokensFb.FirstName)); Assert.That(userAuth.LastName, Is.EqualTo(serviceTokensFb.LastName)); Assert.That(userAuth.PrimaryEmail, Is.EqualTo(serviceTokensFb.Email)); var authProviders = userAuthRepository.GetUserOAuthProviders(oAuthUserSession.UserAuthId); Assert.That(authProviders.Count, Is.EqualTo(2)); Console.WriteLine(userAuth.Dump()); Console.WriteLine(authProviders.Dump()); }
protected void InitTest(IUserAuthRepository userAuthRepository) { ((IClearable)userAuthRepository).Clear(); var appsettingsMock = new Mock <IAppSettings>(); var appSettings = appsettingsMock.Object; new AuthFeature(null, new IAuthProvider[] { new CredentialsAuthProvider(), new BasicAuthProvider(), new FacebookAuthProvider(appSettings), new TwitterAuthProvider(appSettings) }) .Register(null); mockService = new Mock <IServiceBase>(); mockService.Expect(x => x.TryResolve <IAuthRepository>()).Returns(userAuthRepository); requestContext = new BasicRequest { Headers = { { "X-ss-id", SessionExtensions.CreateRandomSessionId() } } }; mockService.Expect(x => x.Request).Returns(requestContext); service = mockService.Object; RegisterDto = new Register { UserName = "******", Password = "******", Email = "*****@*****.**", DisplayName = "DisplayName", FirstName = "FirstName", LastName = "LastName", }; }
public void Does_persist_TwitterOAuth(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); MockAuthHttpGateway.Tokens = twitterGatewayTokens; var authInfo = new Dictionary<string, string> { {"user_id", "133371690876022785"}, {"screen_name", "demisbellot"}, }; var oAuthUserSession = requestContext.ReloadSession(); var twitterAuth = GetTwitterAuthProvider(); twitterAuth.OnAuthenticated(service, oAuthUserSession, twitterAuthTokens, authInfo); oAuthUserSession = requestContext.ReloadSession(); Assert.That(oAuthUserSession.UserAuthId, Is.Not.Null); var userAuth = userAuthRepository.GetUserAuth(oAuthUserSession.UserAuthId); Assert.That(userAuth.Id.ToString(CultureInfo.InvariantCulture), Is.EqualTo(oAuthUserSession.UserAuthId)); Assert.That(userAuth.DisplayName, Is.EqualTo("Demis Bellot TW")); var authProviders = userAuthRepository.GetUserAuthDetails(oAuthUserSession.UserAuthId); Assert.That(authProviders.Count, Is.EqualTo(1)); var authProvider = authProviders[0]; Assert.That(authProvider.UserAuthId, Is.EqualTo(userAuth.Id)); Assert.That(authProvider.DisplayName, Is.EqualTo("Demis Bellot TW")); Assert.That(authProvider.FirstName, Is.Null); Assert.That(authProvider.LastName, Is.Null); Assert.That(authProvider.RequestToken, Is.EqualTo(twitterAuthTokens.RequestToken)); Assert.That(authProvider.RequestTokenSecret, Is.EqualTo(twitterAuthTokens.RequestTokenSecret)); Console.WriteLine(authProviders.Dump()); }
protected object Register(IUserAuthRepository userAuthRepository, AuthUserSession oAuthUserSession, Register register = null) { if (register == null) register = RegisterDto; var registrationService = GetRegistrationService(userAuthRepository, oAuthUserSession, requestContext); var response = registrationService.Post(register); Assert.That(response as IHttpError, Is.Null); return response; }
protected AuthUserSession RegisterAndLogin(IUserAuthRepository userAuthRepository, AuthUserSession oAuthUserSession) { Register(userAuthRepository, oAuthUserSession); Login(RegisterDto.UserName, RegisterDto.Password, oAuthUserSession); oAuthUserSession = requestContext.ReloadSession(); return oAuthUserSession; }
public static RegisterService GetRegistrationService( IUserAuthRepository userAuthRepository, AuthUserSession oAuthUserSession = null, BasicRequest request = null) { if (request == null) request = new BasicRequest(); if (oAuthUserSession == null) oAuthUserSession = request.ReloadSession(); oAuthUserSession.Id = request.Response.CreateSessionId(request); request.Items[ServiceExtensions.RequestItemsSessionKey] = oAuthUserSession; var mockAppHost = new BasicAppHost(); mockAppHost.Container.Register<IAuthRepository>(userAuthRepository); var authService = new AuthenticateService { Request = request, }; authService.SetResolver(mockAppHost); mockAppHost.Register(authService); var registrationService = new RegisterService { AuthRepo = userAuthRepository, Request = request, RegistrationValidator = new RegistrationValidator { UserAuthRepo = RegistrationServiceTests.GetStubRepo() }, }; registrationService.SetResolver(mockAppHost); return registrationService; }
public UserController(IUserAuthRepository userAuthRepository, IRepository <User> userRepository, AuthService authService) { this.userAuthRepository = userAuthRepository; this.userRepository = userRepository; this.authService = authService; }
/// <summary> /// Saves the Auth Tokens for this request. Called in OnAuthenticated(). /// Overrideable, the default behaviour is to call IUserAuthRepository.CreateOrMergeAuthSession(). /// </summary> protected virtual void SaveUserAuth(IServiceBase authService, IAuthSession session, IUserAuthRepository authRepo, IOAuthTokens tokens) { if (authRepo == null) { return; } if (tokens != null) { session.UserAuthId = authRepo.CreateOrMergeAuthSession(session, tokens); } authRepo.LoadUserAuth(session, tokens); foreach (var oAuthToken in session.ProviderOAuthAccess) { var authProvider = AuthService.GetAuthProvider(oAuthToken.Provider); if (authProvider == null) { continue; } var userAuthProvider = authProvider as OAuthProvider; if (userAuthProvider != null) { userAuthProvider.LoadUserOAuthProvider(session, oAuthToken); } } authRepo.SaveUserAuth(session); var httpRes = authService.RequestContext.Get <IHttpResponse>(); if (httpRes != null) { httpRes.Cookies.AddPermanentCookie(HttpHeaders.XUserAuthId, session.UserAuthId); } OnSaveUserAuth(authService, session); }
public AuthController(IUserAuthRepository repo, IConfiguration config, IMapper mapper) { _mapper = mapper; _config = config; _repo = repo; }
public UserController(IUserAuthRepository repository, IUserAuthHandler handler) { _repository = repository; _handler = handler; }
public UserAuthService(IMapper mapper, IUserAuthRepository repository) { _mapper = mapper; _repository = repository; }
public void Registering_twice_creates_two_registrations(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var oAuthUserSession = requestContext.ReloadSession(); RegisterAndLogin(userAuthRepository, oAuthUserSession); requestContext.RemoveSession(); var userName1 = RegisterDto.UserName; var userName2 = "UserName2"; RegisterDto.UserName = userName2; RegisterDto.Email = "*****@*****.**"; var userAuth1 = userAuthRepository.GetUserAuthByUserName(userName1); Assert.That(userAuth1, Is.Not.Null); Register(userAuthRepository, oAuthUserSession, RegisterDto); userAuth1 = userAuthRepository.GetUserAuthByUserName(userName1); var userAuth2 = userAuthRepository.GetUserAuthByUserName(userName2); Assert.That(userAuth1, Is.Not.Null); Assert.That(userAuth2, Is.Not.Null); }
public static void UpdateFromUserAuthRepo(this IAuthSession session, IHttpRequest req, IUserAuthRepository userAuthRepo = null) { if (userAuthRepo == null) { userAuthRepo = req.TryResolve <IUserAuthRepository>(); } if (userAuthRepo == null) { return; } var userAuth = userAuthRepo.GetUserAuth(session, null); session.UpdateSession(userAuth); }
public static IUserAuth GetUserAuth(this IUserAuthRepository authRepo, int userAuthId) { return(authRepo.GetUserAuth(userAuthId.ToString(CultureInfo.InvariantCulture))); }
public UserAuthBL(IUserAuthRepository userAuthRepository) { this.userAuthRepository = userAuthRepository; }
public void Logging_in_pulls_all_AuthInfo_from_repo_after_logging_in_all_AuthProviders(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var oAuthUserSession = requestContext.ReloadSession(); //Facebook LoginWithFacebook(oAuthUserSession); //Twitter MockAuthHttpGateway.Tokens = twitterGatewayTokens; var authInfo = new Dictionary <string, string> { { "user_id", "133371690876022785" }, { "screen_name", "demisbellot" }, }; var twitterAuth = GetTwitterAuthProvider(); twitterAuth.OnAuthenticated(service, oAuthUserSession, twitterAuthTokens, authInfo); Console.WriteLine("UserId: " + oAuthUserSession.UserAuthId); //Register var registrationService = GetRegistrationService(userAuthRepository, oAuthUserSession, requestContext); var responseObj = registrationService.Post(registrationDto); Assert.That(responseObj as IHttpError, Is.Null, responseObj.ToString()); Console.WriteLine("UserId: " + oAuthUserSession.UserAuthId); var credentialsAuth = GetCredentialsAuthConfig(); var loginResponse = credentialsAuth.Authenticate(service, oAuthUserSession, new Auth { provider = CredentialsAuthProvider.Name, UserName = registrationDto.UserName, Password = registrationDto.Password, }); loginResponse.PrintDump(); oAuthUserSession = requestContext.ReloadSession(); Assert.That(oAuthUserSession.TwitterUserId, Is.EqualTo(authInfo["user_id"])); Assert.That(oAuthUserSession.TwitterScreenName, Is.EqualTo(authInfo["screen_name"])); var userAuth = userAuthRepository.GetUserAuth(oAuthUserSession.UserAuthId); Assert.That(userAuth.Id.ToString(CultureInfo.InvariantCulture), Is.EqualTo(oAuthUserSession.UserAuthId)); Assert.That(userAuth.DisplayName, Is.EqualTo(registrationDto.DisplayName)); Assert.That(userAuth.FirstName, Is.EqualTo(registrationDto.FirstName)); Assert.That(userAuth.LastName, Is.EqualTo(registrationDto.LastName)); Assert.That(userAuth.Email, Is.EqualTo(registrationDto.Email)); Console.WriteLine(oAuthUserSession.Dump()); Assert.That(oAuthUserSession.ProviderOAuthAccess.Count, Is.EqualTo(2)); Assert.That(oAuthUserSession.IsAuthenticated, Is.True); var authProviders = userAuthRepository.GetUserOAuthProviders(oAuthUserSession.UserAuthId); Assert.That(authProviders.Count, Is.EqualTo(2)); Console.WriteLine(userAuth.Dump()); Console.WriteLine(authProviders.Dump()); }
public UserAuthController(TokenService tokenService, IUserAuthRepository repository, IUserAuthHandler handler) { _tokenService = tokenService; _repository = repository; _handler = handler; }
public void Setup() { Sut = appHost.Resolve <IUserAuthRepository>(); ((IClearable)Sut).Clear(); }
public void Does_merge_FacebookOAuth_TwitterOAuth(IUserAuthRepository userAuthRepository) { ((IClearable)userAuthRepository).Clear(); var mockService = new Mock <IServiceBase>(); mockService.Expect(x => x.TryResolve <IUserAuthRepository>()) .Returns(userAuthRepository); var service = mockService.Object; var serviceTokensFb = MockAuthHttpGateway.Tokens = new OAuthTokens { UserId = "623501766", DisplayName = "Demis Bellot FB", FirstName = "Demis", LastName = "Bellot", Email = "*****@*****.**", }; var facebookTokens = new OAuthTokens { Provider = FacebookAuthConfig.Name, AccessTokenSecret = "AAADDDCCCoR848BAMkQIZCRIKnVWZAvcKWqo7Ibvec8ebV9vJrfZAz8qVupdu5EbjFzmMmbwUFDbcNDea9H6rOn5SVn8es7KYZD", }; var oAuthUserSession = GetSession(); oAuthUserSession.OnAuthenticated(service, facebookTokens, new Dictionary <string, string>()); var serviceTokensTw = MockAuthHttpGateway.Tokens = new OAuthTokens { DisplayName = "Demis Bellot TW" }; var twitterTokens = new OAuthTokens { Provider = TwitterAuthConfig.Name, RequestToken = "JGGZZ22CCqgB1GR5e0EmGFxzyxGTw2rwEFFcC8a9o7g", RequestTokenSecret = "qKKCCUUJ2R10bMieVQZZad7iSwWkPYJmtBYzPoM9q0", UserId = "133371690876022785", }; var authInfo = new Dictionary <string, string> { { "user_id", "133371690876022785" }, { "screen_name", "demisbellot" }, }; oAuthUserSession.OnAuthenticated(service, twitterTokens, authInfo); Assert.That(oAuthUserSession.TwitterUserId, Is.EqualTo(authInfo["user_id"])); Assert.That(oAuthUserSession.TwitterScreenName, Is.EqualTo(authInfo["screen_name"])); var userAuth = userAuthRepository.GetUserAuth(oAuthUserSession.UserAuthId); Assert.That(userAuth.Id.ToString(), Is.EqualTo(oAuthUserSession.UserAuthId)); Assert.That(userAuth.DisplayName, Is.EqualTo(serviceTokensTw.DisplayName)); Assert.That(userAuth.FirstName, Is.EqualTo(serviceTokensFb.FirstName)); Assert.That(userAuth.LastName, Is.EqualTo(serviceTokensFb.LastName)); Assert.That(userAuth.Email, Is.EqualTo(serviceTokensFb.Email)); var authProviders = userAuthRepository.GetUserOAuthProviders(oAuthUserSession.UserAuthId); Assert.That(authProviders.Count, Is.EqualTo(2)); Console.WriteLine(userAuth.Dump()); Console.WriteLine(authProviders.Dump()); }
public EmployersAuthentificationController(IUserAuthRepository <Employer> authRepos, IConfiguration config, ICompanyRepository companyRepos) { _authRepos = authRepos; Configuration = config; _companyRepos = companyRepos; }
public UnitOfWork(DynamicContext context, IUserRepository userRepository, IUserAuthRepository userAuthRepository) { Context = context; UserRepository = userRepository; UserAuthRepository = userAuthRepository; }
public UserService(IUserAuthRepository userAuthRepository) { this.userAuthRepository = userAuthRepository; }
public static void DeleteUserAuth(this IUserAuthRepository authRepo, int userAuthId) { authRepo.DeleteUserAuth(userAuthId.ToString(CultureInfo.InvariantCulture)); }
public StudentsAuthentificationController(IUserAuthRepository <Student> authRepos, IConfiguration config) { _authRepos = authRepos; Configuration = config; }
public void Logging_in_pulls_all_AuthInfo_from_repo_after_logging_in_all_AuthProviders(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var oAuthUserSession = requestContext.ReloadSession(); //Facebook LoginWithFacebook(oAuthUserSession); //Twitter MockAuthHttpGateway.Tokens = twitterGatewayTokens; var authInfo = new Dictionary<string, string> { {"user_id", "133371690876022785"}, {"screen_name", "demisbellot"}, }; var twitterAuth = GetTwitterAuthProvider(); twitterAuth.OnAuthenticated(service, oAuthUserSession, twitterAuthTokens, authInfo); Console.WriteLine("UserId: " + oAuthUserSession.UserAuthId); //Register var registrationService = GetRegistrationService(userAuthRepository, oAuthUserSession, requestContext); var responseObj = registrationService.Post(RegisterDto); Assert.That(responseObj as IHttpError, Is.Null, responseObj.ToString()); Console.WriteLine("UserId: " + oAuthUserSession.UserAuthId); var credentialsAuth = GetCredentialsAuthConfig(); var loginResponse = credentialsAuth.Authenticate(service, oAuthUserSession, new Authenticate { provider = CredentialsAuthProvider.Name, UserName = RegisterDto.UserName, Password = RegisterDto.Password, }); loginResponse.PrintDump(); oAuthUserSession = requestContext.ReloadSession(); Assert.That(oAuthUserSession.TwitterUserId, Is.EqualTo(authInfo["user_id"])); Assert.That(oAuthUserSession.TwitterScreenName, Is.EqualTo(authInfo["screen_name"])); var userAuth = userAuthRepository.GetUserAuth(oAuthUserSession.UserAuthId); Assert.That(userAuth.Id.ToString(CultureInfo.InvariantCulture), Is.EqualTo(oAuthUserSession.UserAuthId)); Assert.That(userAuth.DisplayName, Is.EqualTo(RegisterDto.DisplayName)); Assert.That(userAuth.FirstName, Is.EqualTo(RegisterDto.FirstName)); Assert.That(userAuth.LastName, Is.EqualTo(RegisterDto.LastName)); Assert.That(userAuth.Email, Is.EqualTo(RegisterDto.Email)); Console.WriteLine(oAuthUserSession.Dump()); Assert.That(oAuthUserSession.ProviderOAuthAccess.Count, Is.EqualTo(2)); Assert.That(oAuthUserSession.IsAuthenticated, Is.True); var authProviders = userAuthRepository.GetUserAuthDetails(oAuthUserSession.UserAuthId); Assert.That(authProviders.Count, Is.EqualTo(2)); Console.WriteLine(userAuth.Dump()); Console.WriteLine(authProviders.Dump()); }
public UserAuthBusiness(IUserAuthRepository repository, IUnitOfWork unitOfWork) : base(repository, unitOfWork) { UnitOfWork = unitOfWork; UserAuthRepository = repository; }
public void Registering_twice_in_same_session_updates_registration(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var oAuthUserSession = requestContext.ReloadSession(); oAuthUserSession = RegisterAndLogin(userAuthRepository, oAuthUserSession); var userName1 = RegisterDto.UserName; var userName2 = "UserName2"; RegisterDto.UserName = userName2; Register(userAuthRepository, oAuthUserSession, RegisterDto); var userAuth1 = userAuthRepository.GetUserAuthByUserName(userName1); var userAuth2 = userAuthRepository.GetUserAuthByUserName(userName2); Assert.That(userAuth1, Is.Null); Assert.That(userAuth2, Is.Not.Null); }
public static void RecordSuccessfulLogin(this IUserAuthRepository repo, IUserAuth userAuth) { repo.RecordSuccessfulLogin(userAuth, rehashPassword: false, password: null); }
public void Can_DeleteUserAuth(IUserAuthRepository userAuthRepository) { InitTest(userAuthRepository); var oAuthUserSession = requestContext.ReloadSession(); oAuthUserSession = RegisterAndLogin(userAuthRepository, oAuthUserSession); var userAuth = userAuthRepository.GetUserAuthByUserName(RegisterDto.UserName); Assert.That(userAuth, Is.Not.Null); userAuthRepository.DeleteUserAuth(userAuth.Id.ToString()); userAuth = userAuthRepository.GetUserAuthByUserName(RegisterDto.UserName); Assert.That(userAuth, Is.Null); }
public void Does_persist_TwitterOAuth(IUserAuthRepository userAuthRepository) { ((IClearable)userAuthRepository).Clear(); var mockService = new Mock<IServiceBase>(); mockService.Expect(x => x.TryResolve<IUserAuthRepository>()) .Returns(userAuthRepository); var service = mockService.Object; MockAuthHttpGateway.Tokens = new OAuthTokens { DisplayName = "Demis Bellot TW" }; var twitterTokens = new OAuthTokens { Provider = TwitterAuthConfig.Name, RequestToken = "JGz2CcwqgB1GR5e0EmGFxzyxGTw2rwEFFcC8a9o7g", RequestTokenSecret = "qkCdURJ2R10bMieVQZZad7iSwWkPYJmtBYzPoM9q0", UserId = "133371690876022785", }; var authInfo = new Dictionary<string, string> { {"user_id", "133371690876022785"}, {"screen_name", "demisbellot"}, }; var oAuthUserSession = GetSession(); oAuthUserSession.OnAuthenticated(service, twitterTokens, authInfo); Assert.That(oAuthUserSession.UserAuthId, Is.Not.Null); var userAuth = userAuthRepository.GetUserAuth(oAuthUserSession.UserAuthId); Assert.That(userAuth.Id.ToString(), Is.EqualTo(oAuthUserSession.UserAuthId)); Assert.That(userAuth.DisplayName, Is.EqualTo("Demis Bellot TW")); var authProviders = userAuthRepository.GetUserOAuthProviders(oAuthUserSession.UserAuthId); Assert.That(authProviders.Count, Is.EqualTo(1)); var authProvider = authProviders[0]; Assert.That(authProvider.UserAuthId, Is.EqualTo(userAuth.Id)); Assert.That(authProvider.DisplayName, Is.EqualTo("Demis Bellot TW")); Assert.That(authProvider.FirstName, Is.Null); Assert.That(authProvider.LastName, Is.Null); Assert.That(authProvider.RequestToken, Is.EqualTo(twitterTokens.RequestToken)); Assert.That(authProvider.RequestTokenSecret, Is.EqualTo(twitterTokens.RequestTokenSecret)); Console.WriteLine(authProviders.Dump()); }
public UserAuthHandler(IUserAuthRepository repository, IAccessLogRepository log) { _repository = repository; _log = log; }
public void Can_login_with_user_created_CreateUserAuth(IUserAuthRepository userAuthRepository) { ((IClearable)userAuthRepository).Clear(); var request = new Registration { UserName = "******", Password = "******", Email = "*****@*****.**", DisplayName = "DisplayName", FirstName = "FirstName", LastName = "LastName", }; var loginService = new RegistrationService { UserAuthRepo = userAuthRepository, RegistrationValidator = new RegistrationValidator { UserAuthRepo = RegistrationServiceTests.GetStubRepo() }, }; var responseObj = loginService.Post(request); var httpResult = responseObj as IHttpResult; if (httpResult != null) { Assert.Fail("HttpResult found: " + httpResult.Dump()); } var response = (RegistrationResponse)responseObj; Assert.That(response.UserId, Is.Not.Null); var userAuth = userAuthRepository.GetUserAuth(response.UserId); AssertEqual(userAuth, request); userAuth = userAuthRepository.GetUserAuthByUserName(request.UserName); AssertEqual(userAuth, request); userAuth = userAuthRepository.GetUserAuthByUserName(request.Email); AssertEqual(userAuth, request); string userId; var success = userAuthRepository.TryAuthenticate(request.UserName, request.Password, out userId); Assert.That(success, Is.True); Assert.That(userId, Is.Not.Null); success = userAuthRepository.TryAuthenticate(request.Email, request.Password, out userId); Assert.That(success, Is.True); Assert.That(userId, Is.Not.Null); success = userAuthRepository.TryAuthenticate(request.UserName, "Bad Password", out userId); Assert.That(success, Is.False); Assert.That(userId, Is.Null); }