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