public async Task <IActionResult> Registration(
CancellationToken cancellationToken,
[FromBody] RegistrationBinding binding,
[FromServices] IUserRepository userRepository,
[FromServices] UserRegistrationService registrationService)
{
var user = await userRepository.FindByLogin(binding.Login, cancellationToken);
if (user != null)
{
return(Conflict());
}
user = await registrationService.CreateUser(binding.Email,
binding.Login, binding.Password, 1, binding.NumberPhone,
DateTime.Now, DateTime.Now, binding.FirstName, binding.LastName,
binding.MiddleName, binding.Hobby, binding.DateOfBirth, (AuthType)binding.AuthTypeBinding, cancellationToken);
try
{
await userRepository.Save(user);
return(NoContent());
}
catch (DbUpdateException exception)
when(((Npgsql.PostgresException)exception.InnerException)?.SqlState == "23505")
{
return(Conflict());
}
}
public AuthController(AuthService authService, UserRegistrationService userRegistrationService,
IUnitOfWork unitOfWork)
{
_authService = authService;
_userRegistrationService = userRegistrationService;
_unitOfWork = unitOfWork;
}
public async Task <IActionResult> Registration(
CancellationToken cancellationToken,
[FromForm] RegistrationBinding binding,
[FromServices] IUserRepository userRepository,
[FromServices] UserRegistrationService registrationService)
{
var user = await userRepository.FindByEmail(binding.Email, cancellationToken);
if (user != null)
{
if (user.EmailState == EmailState.Unconfirmed)
{
return(NoContent());
}
return(Conflict());
}
user = await registrationService.CreateUser(binding.Email, binding.Password, cancellationToken);
try
{
await userRepository.Save(user);
return(NoContent());
}
catch (DbUpdateException exception)
when(((Npgsql.PostgresException)exception.InnerException)?.SqlState == "23505") // 23505 unique_violation
{
return(Conflict());
}
}
public static UserRegistrationService GetRegistrationService(
AbstractValidator <UserRegistrationRequest> validator = null,
IUserAuthRepository authRepo = null,
string contentType = null)
{
var requestContext = new BasicRequest();
if (contentType != null)
{
requestContext.ResponseContentType = contentType;
}
var userAuthRepository = authRepo ?? GetStubRepo();
var service = new UserRegistrationService
{
UserRegistrationRequestValidator = validator ?? new UserRegistrationRequestValidator {
UserAuthRepo = userAuthRepository
},
AuthRepo = userAuthRepository,
Request = requestContext,
};
HostContext.Container.Register(userAuthRepository);
return(service);
}
public AppReturnObject Register(UserAccount userRegistration)
{
var _user = new AppUser()
{
UserName = userRegistration.UserName,
Email = userRegistration.Email,
FirstName = userRegistration.FirstName,
LastName = userRegistration.LastName,
Country = userRegistration.Country,
Address = userRegistration.Address,
Password = userRegistration.Password
};
var _serviceResult = new UserRegistrationService().Register(_user);
AppReturnObject _retval = new AppReturnObject()
{
Succeeded = _serviceResult.Succeeded, Errors = _serviceResult.Errors.ToList()
};
if (_serviceResult.Succeeded)
{
userRegistration.Id = _user.Id;
userRegistration.CurrentBalance = _user.CurrentBalance;
_retval.UserAccount = userRegistration;
}
return(_retval);
}
public void Login_fails_with_empty_inputs()
{
var store = new Mock<IUserRegistrationStore>();
var svc = new UserRegistrationService(store.Object);
Assert.Throws<ArgumentNullException>(() => svc.Login("*****@*****.**", null));
Assert.Throws<ArgumentNullException>(() => svc.Login(null, "password"));
}
public RegisterUser()
{
registerService = new UserRegistrationService();
registerService.EnableDecompression = true;
string soapServer = CurrentValues.Instance.YodleeSoapServer;
registerService.Url = soapServer + "/" + registerService.GetType().FullName;
}
public void Fails_with_empty_inputs()
{
var store = new Mock<IUserRegistrationStore>();
var svc = new UserRegistrationService(store.Object);
Assert.Throws<ArgumentNullException>(() => svc.Register(null, "password"));
Assert.Throws<ArgumentNullException>(() => svc.Register("email", null));
}
public void Registration_fails_with_duplicate_emails()
{
var store = new UserRegistrationStore();
var svc = new UserRegistrationService(store);
svc.Register("*****@*****.**", "password");
Assert.Throws<DbUpdateException>(() => svc.Register("*****@*****.**", "other"));
}
public void Setup()
{
_mockRepository = new Mock <IUserRepository>();
_service = new UserRegistrationService
(
_mockRepository.Object
);
}
public void End_to_end_failed_login()
{
var store = new UserRegistrationStore();
var svc = new UserRegistrationService(store);
svc.Register("*****@*****.**", "password");
Assert.Equal(Guid.Empty, svc.Login("*****@*****.**", "wrong"));
Assert.Equal(Guid.Empty, svc.Login("*****@*****.**", "password"));
}
public MongoRepositoryFactoryTests()
{
_connectionString = new ConnectionStringFactory();
_mongoRepository = new MongoRepositoryFactory(_connectionString);
_logRepository = new LogsRepository(_mongoRepository);
_playerRepository = new PlayerRepository(_mongoRepository);
_baseRepository = new BaseRepository(_mongoRepository);
_usefulLinkRepository = new UsefulLinkRepository(_mongoRepository);
_userRepository = new UserRepository(_mongoRepository);
_registrationService = new UserRegistrationService(_userRepository);
}
public void Service_can_verify_credentials()
{
var reg = new UserRegistration("*****@*****.**", "password");
var store = new Mock<IUserRegistrationStore>();
store.Setup(x => x.Load("*****@*****.**")).Returns(reg);
var svc = new UserRegistrationService(store.Object);
var result = svc.Login("*****@*****.**", "password");
store.VerifyAll();
Assert.Equal(reg.Id, result);
}
public void End_to_end_success()
{
var store = new UserRegistrationStore();
var svc = new UserRegistrationService(store);
svc.Register("*****@*****.**", "password");
var id = svc.Login("*****@*****.**", "password");
Assert.NotEqual(Guid.Empty, id);
var user = store.Users.FirstOrDefault(x => x.Id == id);
Assert.Equal("*****@*****.**", user.Email);
}
public void Login_fails_with_wrong_password()
{
var reg = new UserRegistration("*****@*****.**", "password");
var store = new Mock<IUserRegistrationStore>();
store.Setup(x => x.Load("*****@*****.**")).Returns(reg);
var svc = new UserRegistrationService(store.Object);
var result = svc.Login("*****@*****.**", "wrong");
store.VerifyAll();
Assert.NotEqual(reg.Id, result);
Assert.Equal(new Guid(), result);
}
/// controls END
#endregion
#region BASE_METHODS
protected override async Task OnInitializedAsync()
{
NewCompany = new CompanyRegistrationDTO();
AddLemlistStatistic = new AddLemlistStatistic();
checkedContacts = new List <int>();
await TempService.UpdateCompanies();
await RenderUpdate();
authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
user = authState.User;
if (user.Identity.IsAuthenticated)
{
TempService.CurrentUser = await UserRegistrationService.GetCurrent(user.Identity.Name);
}
await StartCountdown();
}
public CreateUserStatus CreateUser(RegistrationData user,
[Required(ErrorMessageResourceName = "ValidationErrorRequiredField", ErrorMessageResourceType = typeof(ValidationErrorResources))]
[RegularExpression("^.*[^a-zA-Z0-9].*$", ErrorMessageResourceName = "ValidationErrorBadPasswordStrength", ErrorMessageResourceType = typeof(ValidationErrorResources))]
[StringLength(50, MinimumLength = 7, ErrorMessageResourceName = "ValidationErrorBadPasswordLength", ErrorMessageResourceType = typeof(ValidationErrorResources))]
string password)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
// Run this BEFORE creating the user to make sure roles are enabled and the default role is available.
//
// If there is a problem with the role manager, it is better to fail now than to fail after the user is created.
if (!Roles.RoleExists(UserRegistrationService.DefaultRole))
{
Roles.CreateRole(UserRegistrationService.DefaultRole);
}
// NOTE: ASP.NET by default uses SQL Server Express to create the user database.
// CreateUser will fail if you do not have SQL Server Express installed.
MembershipCreateStatus createStatus;
Membership.CreateUser(user.UserName, password, user.Email, user.Question, user.Answer, true, null, out createStatus);
if (createStatus != MembershipCreateStatus.Success)
{
return(UserRegistrationService.ConvertStatus(createStatus));
}
// Assign the user to the default role.
// This will fail if role management is disabled.
Roles.AddUserToRole(user.UserName, UserRegistrationService.DefaultRole);
// Set the friendly name (profile setting).
// This will fail if the web.config is configured incorrectly.
ProfileBase profile = ProfileBase.Create(user.UserName, true);
profile.SetPropertyValue("FriendlyName", user.FriendlyName);
profile.Save();
return(CreateUserStatus.Success);
}
public async Task <IActionResult> ResendConfirmationCode(
CancellationToken cancellationToken,
[FromRoute] string email,
[FromServices] IUserRepository userRepository,
[FromServices] UserRegistrationService userRegistrationService)
{
var user = await userRepository.FindByEmail(email, cancellationToken);
if (user == null)
{
return(NotFound());
}
if (user.EmailState != EmailState.Unconfirmed)
{
return(UnprocessableEntity());
}
await userRegistrationService.ResendConfirmationCode(user, cancellationToken);
return(NoContent());
}
public void Requires_unique_UserName_and_Email()
{
var mockExistingUser = new UserAuth();
var mock = new Mock <IUserAuthRepository>();
mock.Setup(x => x.GetUserAuthByUserName(It.IsAny <string>()))
.Returns(() => mockExistingUser).Verifiable();
var mockUserAuth = mock.Object;
var service = new UserRegistrationService
{
UserRegistrationRequestValidator = new UserRegistrationRequestValidator {
UserAuthRepo = mockUserAuth
},
AuthRepo = mockUserAuth,
};
var request = new UserRegistrationRequest
{
DisplayName = "DisplayName",
Email = "*****@*****.**",
FirstName = "FirstName",
LastName = "LastName",
Password = "******",
UserName = "******",
};
var response = PostRegistrationError(service, request);
var errors = response.GetFieldErrors();
Assert.That(errors.Count, Is.EqualTo(2));
Assert.That(errors[0].ErrorCode, Is.EqualTo("AlreadyExists"));
Assert.That(errors[0].FieldName, Is.EqualTo("UserName"));
Assert.That(errors[1].ErrorCode, Is.EqualTo("AlreadyExists"));
Assert.That(errors[1].FieldName, Is.EqualTo("Email"));
mock.Verify();
}
public static UserRegistrationService GetRegistrationService(
AbstractValidator<UserRegistrationRequest> validator = null,
IUserAuthRepository authRepo = null,
string contentType = null)
{
var requestContext = new BasicRequest();
if (contentType != null)
{
requestContext.ResponseContentType = contentType;
}
var userAuthRepository = authRepo ?? GetStubRepo();
var service = new UserRegistrationService
{
UserRegistrationRequestValidator = validator ?? new UserRegistrationRequestValidator { UserAuthRepo = userAuthRepository },
AuthRepo = userAuthRepository,
Request = requestContext,
};
HostContext.Container.Register(userAuthRepository);
return service;
}
public FinishUserRegistrationEventHandler(UserRegistrationService userRegistrationService)
{
_userRegistrationService = userRegistrationService;
}
public void Stores_registration_with_email(string email, string password)
{
var store = new Mock<IUserRegistrationStore>();
store.Setup(x => x.Save(It.Is<UserRegistration>(r => r.Email == email)));
var svc = new UserRegistrationService(store.Object);
svc.Register(email, password);
store.VerifyAll();
}
public RegisterUser()
{
registerService = new UserRegistrationService();
registerService.EnableDecompression = true;
registerService.Url = System.Configuration.ConfigurationManager.AppSettings.Get("soapServer") + "/" + registerService.GetType().FullName;
}
public SignInController()
{
UserManager = new UserService();
UserRegistrationService = new UserRegistrationService();
}
private void ConfigureValidationRules()
{
Validator.AddRequiredRule(() => UserName, "User Name is required");
Validator.AddAsyncRule(nameof(UserName),
async() =>
{
var isAvailable = await UserRegistrationService.IsUserNameAvailable(UserName).ToTask();
return(RuleResult.Assert(isAvailable,
string.Format("User Name {0} is taken. Please choose a different one.", UserName)));
});
Validator.AddRequiredRule(() => FirstName, "First Name is required");
Validator.AddRequiredRule(() => LastName, "Last Name is required");
Validator.AddRequiredRule(() => Email, "Email is required");
Validator.AddRule(nameof(Email),
() =>
{
const string regexPattern =
@"^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$";
return(RuleResult.Assert(Regex.IsMatch(Email, regexPattern),
"Email must by a valid email address"));
});
Validator.AddRequiredRule(() => Password, "Password is required");
Validator.AddRule(nameof(Password),
() => RuleResult.Assert(Password.Length >= 6,
"Password must contain at least 6 characters"));
Validator.AddRule(nameof(Password),
() => RuleResult.Assert((!Password.All(char.IsLower) &&
!Password.All(char.IsUpper) &&
!Password.All(char.IsDigit)),
"Password must contain both lower case and upper case letters"));
Validator.AddRule(nameof(Password),
() => RuleResult.Assert(Password.Any(char.IsDigit),
"Password must contain at least one digit"));
Validator.AddRule(nameof(PasswordConfirmation),
() =>
{
if (!string.IsNullOrEmpty(Password) && string.IsNullOrEmpty(PasswordConfirmation))
{
return(RuleResult.Invalid("Please confirm password"));
}
return(RuleResult.Valid());
});
Validator.AddRule(nameof(Password),
nameof(PasswordConfirmation),
() =>
{
if (!string.IsNullOrEmpty(Password) && !string.IsNullOrEmpty(PasswordConfirmation))
{
return(RuleResult.Assert(Password == PasswordConfirmation, "Passwords do not match"));
}
return(RuleResult.Valid());
});
Validator.AddChildValidatable(() => InterestSelectorViewModel);
}
public SignUpController()
{
UserRegistrationService = new UserRegistrationService();
}
private static HttpError PostRegistrationError(UserRegistrationService service, UserRegistrationRequest register)
{
var response = (HttpError)service.RunAction(register, (svc, req) => svc.Post(req));
return(response);
}
public ServiceController()
{
UserProfileService = new UserProfileService();
NotificationService = new NotificationService();
UserRegistrationService = new UserRegistrationService();
}
public PasswordResetController()
{
UserRegistrationService = new UserRegistrationService();
}
public SynchronizePendingUserEventHandler(UserRegistrationService userRegistrationService)
{
_userRegistrationService = userRegistrationService;
}
private void CreateUserRegistrationService()
{
PasswordHashService = MockRepository.GenerateStub <IPasswordHashService>();
UserRepository = new InMemoryUserRepository();
Service = new UserRegistrationService(UserRepository, PasswordHashService);
}
public void Requires_unique_UserName_and_Email()
{
var mockExistingUser = new UserAuth();
var mock = new Mock<IUserAuthRepository>();
mock.Setup(x => x.GetUserAuthByUserName(It.IsAny<string>()))
.Returns(() => mockExistingUser).Verifiable();
var mockUserAuth = mock.Object;
var service = new UserRegistrationService
{
UserRegistrationRequestValidator = new UserRegistrationRequestValidator { UserAuthRepo = mockUserAuth },
AuthRepo = mockUserAuth,
};
var request = new UserRegistrationRequest
{
DisplayName = "DisplayName",
Email = "*****@*****.**",
FirstName = "FirstName",
LastName = "LastName",
Password = "******",
UserName = "******",
};
var response = PostRegistrationError(service, request);
var errors = response.GetFieldErrors();
Assert.That(errors.Count, Is.EqualTo(2));
Assert.That(errors[0].ErrorCode, Is.EqualTo("AlreadyExists"));
Assert.That(errors[0].FieldName, Is.EqualTo("UserName"));
Assert.That(errors[1].ErrorCode, Is.EqualTo("AlreadyExists"));
Assert.That(errors[1].FieldName, Is.EqualTo("Email"));
mock.Verify();
}
public new void SetUp()
{
_userSettings = new UserSettings
{
UnduplicatedPasswordsNumber = 1,
HashedPasswordFormat = "SHA512",
};
_securitySettings = new SecuritySettings
{
EncryptionKey = "273ece6f97dd844d"
};
_encryptionService = new EncryptionService(_securitySettings);
#region User Setup
_userRepository = new Mock <IRepository <User> >();
var user1 = new User
{
Id = 1,
Username = "******",
Email = "*****@*****.**",
Active = true
};
AddUserToRegisteredRole(user1);
var user2 = new User
{
Id = 2,
Username = "******",
Email = "*****@*****.**",
Active = true
};
AddUserToRegisteredRole(user2);
var user3 = new User
{
Id = 3,
Username = "******",
Email = "*****@*****.**",
Active = true
};
AddUserToRegisteredRole(user3);
var user4 = new User
{
Id = 4,
Username = "******",
Email = "*****@*****.**",
Active = true
};
AddUserToRegisteredRole(user4);
var user5 = new User
{
Id = 5,
Username = "******",
Email = "*****@*****.**",
Active = true
};
var mockUsers = new List <User> {
user1, user2, user3, user4, user5
}.AsQueryable().BuildMockDbSet();
_userRepository.Setup(x => x.Table).Returns(mockUsers.Object);
#endregion
#region UserPassword Setup
_userPasswordRepository = new Mock <IRepository <UserPassword> >();
var saltKey = _encryptionService.CreateSaltKey(5);
var password = _encryptionService.CreatePasswordHash("password", saltKey, "SHA512");
var password1 = new UserPassword
{
UserId = user1.Id,
PasswordFormat = PasswordFormat.Hashed,
PasswordSalt = saltKey,
Password = password,
CreatedOnUtc = DateTime.UtcNow
};
var password2 = new UserPassword
{
UserId = user2.Id,
PasswordFormat = PasswordFormat.Clear,
Password = "******",
CreatedOnUtc = DateTime.UtcNow
};
var password3 = new UserPassword
{
UserId = user3.Id,
PasswordFormat = PasswordFormat.Encrypted,
Password = _encryptionService.EncryptText("password"),
CreatedOnUtc = DateTime.UtcNow
};
var password4 = new UserPassword
{
UserId = user4.Id,
PasswordFormat = PasswordFormat.Clear,
Password = "******",
CreatedOnUtc = DateTime.UtcNow
};
var password5 = new UserPassword
{
UserId = user5.Id,
PasswordFormat = PasswordFormat.Clear,
Password = "******",
CreatedOnUtc = DateTime.UtcNow
};
var mockUserPasswords = new[] { password1, password2, password3, password4, password5 }
.AsQueryable().BuildMockDbSet();
_userPasswordRepository.Setup(x => x.Table).Returns(mockUserPasswords.Object);
#endregion
_roleRepository = new Mock <IRepository <Role> >();
_userRoleRepository = new Mock <IRepository <UserRole> >();
_genericAttributeRepository = new Mock <IRepository <GenericAttribute> >();
_genericAttributeService = new Mock <IGenericAttributeService>();
_workContext = new Mock <IWorkContext>();
_eventPublisherService = new Mock <IEventPublisher>();
_userService = new UserService(
new UserSettings(),
new NullCache(),
null,
null,
_eventPublisherService.Object,
_genericAttributeService.Object,
_userRepository.Object,
_roleRepository.Object,
_userRoleRepository.Object,
_userPasswordRepository.Object,
_genericAttributeRepository.Object,
null);
_userRegistrationService = new UserRegistrationService(_userSettings, _userService, _encryptionService);
}
public void Stores_new_UserRegistration()
{
var store = new Mock<IUserRegistrationStore>();
store.Setup(x => x.Save(It.IsAny<UserRegistration>()));
var svc = new UserRegistrationService(store.Object);
svc.Register("*****@*****.**", "password");
store.VerifyAll();
}
private static HttpError PostRegistrationError(UserRegistrationService service, UserRegistrationRequest register)
{
var response = (HttpError)service.RunAction(register, (svc, req) => svc.Post(req));
return response;
}
