public async Task ThrowException_IfUsernameIsLessThanThreeSymbols()
{
var username = "******";
var password = "******";
var email = "TestEmail";
var role = "TestRole";
var loggerMock = new Mock <ILogger <UserService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowException_IfUsernameIsLessThanThreeSymbols));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var accountDto = new RegisterAccountDto
{
UserName = username,
Password = password,
Role = role,
Email = email
};
var accountService = new UserService(actContext, null, loggerMock);
await accountService.RegisterAccountAsync(accountDto);
}
}
public async Task ThrowExeptionWhenUserEmailIsMoreThanMaxLength_Test()
{
var username = "******";
var password = "******";
var email = new String('T', 51);
var role = "Manager";
var loggerMock = new Mock <ILogger <UserService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowExeptionWhenUserEmailIsMoreThanMaxLength_Test));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var accountDto = new RegisterAccountDto
{
UserName = username,
Password = password,
Role = role,
Email = email
};
var accountService = new UserService(actContext, null, loggerMock);
await accountService.RegisterAccountAsync(accountDto);
}
}
public static void ValidatorUserName(RegisterAccountDto registerAccountDto)
{
if (registerAccountDto.UserName.Length < 3 || registerAccountDto.UserName.Length > 50)
{
throw new UserExeption("Username must be betweeen 3 and 50 symbols!");
}
}
public async Task <IActionResult> RegisterAccount(RegisterAccountViewModel viewModel)
{
try
{
var registerAccountDto = new RegisterAccountDto
{
CurrentUserId = User.FindFirstValue(ClaimTypes.NameIdentifier),
UserName = viewModel.UserName,
Password = viewModel.Password,
Email = viewModel.Email,
Role = viewModel.Role
};
await this.service.RegisterAccountAsync(registerAccountDto);
}
catch (UserExeption ex)
{
return(View("Message", new MessageViewModel {
Message = ex.Message
}));
}
return(View("Message", new MessageViewModel
{
Message = $"Successful registration",
IsSuccess = true
}));
}
public static void ValidatorRoleName(RegisterAccountDto registerAccountDto)
{
if (registerAccountDto.Role != "Manager" && registerAccountDto.Role != "Operator")
{
throw new UserExeption("Wrong role name!");
}
}
public static void ValidatorPassword(RegisterAccountDto registerAccountDto)
{
if (registerAccountDto.Password.Length < 5 || registerAccountDto.Password.Length > 100)
{
throw new UserExeption("Password must be betweeen 5 and 100 symbols!");
}
}
public static void ValidatorForExistUsername(string username, RegisterAccountDto registerAccountDto)
{
if (username != null)
{
throw new UserExeption($"You cannot register accout with the following username {registerAccountDto.UserName}");
}
}
public void Register([FromBody] RegisterAccountDto model)
{
if (!_roleManager.RoleExistsAsync(Roles.Administrator).Result)
{
throw new ApplicationException(ExceptionMessages.RolesHaveNotBeenCreated);
}
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email
};
var result = _userManager.CreateAsync(user, model.Password).Result;
if (!result.Succeeded)
{
throw new ApplicationException(ExceptionMessages.UsernameAlreadyExists);
}
using (var dbContext = new ApplicationDbContext())
{
var appUser = _userManager.Users.SingleOrDefault(au => au.Email == model.Email);
result = _userManager.AddToRoleAsync(appUser, Roles.Administrator).Result;
if (!result.Succeeded)
{
throw new ApplicationException(ExceptionMessages.InternalServerError);
}
if (string.IsNullOrWhiteSpace(model.Logo))
{
model.Logo = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFoAAAAoBAMAAACMbPD7AAAAG1BMVEXMzMyWlpbFxcWjo6OqqqqxsbGcnJy+vr63t7eN+fR5AAAACXBIWXMAAA7EAAAOxAGVKw4bAAAApElEQVQ4je2QsQrCQBBEJ5fLpt2AHxCJWCc2WkZFsTwx9kcQ0ypK6lR+t3eInWw6q3vVLrwdlgECgcAvVFXqy3dm7GvR1ubczMxnjjnZ7ESbclqmJZK6B54c3x6iHYGsslBdByyYMBft2BwZDLxcvuHIXUuoatu6bEwHFGDK5ewUhf8bJ4t7lhUjf9Nw8J2oduWW0U7Sq9ETX2Tvbaxr0Q4E/s8bo1sUV4qjWrAAAAAASUVORK5CYII=";
}
if (!dbContext.Cities.Any(c => c.Id == model.City))
{
throw new ApplicationException(ExceptionMessages.BadRequest);
}
var clinic = new Clinic
{
Name = model.Name,
Description = model.Description,
CityId = model.City,
Address = model.Address,
Latitude = model.Latitude,
Longitude = model.Longitude,
UserId = appUser.Id,
Logo = model.Logo
};
dbContext.Clinics.Add(clinic);
dbContext.SaveChanges();
}
}
public async Task <IActionResult> RegisterMod([FromBody] RegisterAccountDto model)
{
var result = await _accountService.RegisterModAccountAsync(model);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(Ok(result.Token));
}
public static void ValidatorUserEmail(RegisterAccountDto registerAccountDto)
{
if (registerAccountDto.Email == null)
{
throw new UserExeption("Email cannot be null!");
}
if (registerAccountDto.Email.Length < 5 || registerAccountDto.Email.Length > 50)
{
throw new UserExeption("Email must be betweeen 5 and 50 symbols!");
}
}
private async Task <RegisterResult> Regist(RegisterAccountDto registerAccountModel)
{
var registModel = new RegisterModel()
{
Account = registerAccountModel.UserAccount,
Password = registerAccountModel.Password
};
var RegistResult = await authenticationService.Register(registModel);
return(RegistResult);
}
public async Task <ActionResult <UserRegisteredDto> > RegisterAccount([FromBody] RegisterAccountDto model)
{
var registerAccountModel = _mapper.Map <RegisterAccountModel>(model);
var user = await _userLogic.RegisterAccount(registerAccountModel);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
return(Ok(user));
}
public async Task <AccountResponse> RegisterModAccountAsync(RegisterAccountDto model)
{
Dictionary <string, string[]> errors = new Dictionary <string, string[]>();
UserAccount UserAdmin = _context.Users.FirstOrDefault(e => e.Email == _userName || e.UserName == _userName);
UserAccount userr = _context.Users.FirstOrDefault(e => e.Email == model.Email || e.UserName == model.UserName);
if (UserAdmin.Rola != "admin" && UserAdmin.Rola != "moderator")
{
errors.Add("Rola", new[] { "NIe masz tutaj dostępu" });
return(new AccountResponse(errors));
}
if (userr != null)
{
errors.Add("Emial", new[] { "Email jets juz zajety" });
return(new AccountResponse(errors));
}
userr = _context.Users.FirstOrDefault(e => e.NormalizedUserName == model.UserName.ToUpper());
if (userr != null)
{
errors.Add("Useranme", new[] { "Nazwa uzytkoniwka jest juz zajeta" });
return(new AccountResponse(errors));
}
UserAccount user = _mapper.Map <RegisterAccountDto, UserAccount>(model);
var result = await _userManager.CreateAsync(user, model.Password);
string rola = "moderator";
user.Rola = rola;
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
errors.Add(error.Code, new[] { error.Description });
}
return(new AccountResponse(errors));
}
_context.SaveChanges();
UserAccount appUser = _userManager.Users.SingleOrDefault(r => r.Email == model.Email);
JwtTokenDto response = new JwtTokenDto
{
Token = GenerateJwtToken(model.Email, appUser)
};
return(new AccountResponse(response));
}
public async Task <IActionResult> Register([FromBody] RegisterAccountDto item)
{
var account = await _accountRepository.GetByUserName(item.UserName);
if (account != null)
{
return(Error($"Account with username :{item.UserName} already registered."));
}
await _accountRepository.CreateAccount(new UserAccounts
{
UserName = item.UserName,
Password = item.Password.ToSha256(),
Role = item.Role
});
return(Ok());
}
public async Task <IActionResult> Register(RegisterAccountDto registerDtoViewModel)
{
if (!ModelState.IsValid)
{
return(View(registerDtoViewModel));
}
var checkUser = await _userManager.FindByNameAsync(registerDtoViewModel.UserName);
if (checkUser != null)
{
ViewBag.RegisterError = $"Tài khoản {registerDtoViewModel.UserName} đã tồn tại!";
return(View(registerDtoViewModel));
}
var checkEmail = await _userManager.FindByEmailAsync(registerDtoViewModel.Email);
if (checkEmail != null)
{
ViewBag.RegisterError = $"Email {registerDtoViewModel.Email} đã được sử dụng!";
return(View(registerDtoViewModel));
}
AppUser newUser = new AppUser(registerDtoViewModel.UserName)
{
Email = registerDtoViewModel.Email
};
var createUserResult = await _userManager.CreateAsync(newUser, registerDtoViewModel.Password);
if (!createUserResult.Succeeded)
{
ViewBag.RegisterError = $"Có lỗi khi tạo tài khoản, xin vui lòng liên hệ quản trị viên!";
return(View(registerDtoViewModel));
}
await SendEmailConfirmationLink(newUser, registerDtoViewModel.ReturnUrl);
var context = await _identityServerInteractionService
.GetAuthorizationContextAsync(registerDtoViewModel.ReturnUrl);
if (context != null && string.Equals(context.ClientId, "mvc_admin"))
{
return(Redirect(_configuration["AdminHost"]));
}
return(Redirect(_configuration["ClientHost"]));
}
private async Task AutoLogin(RegisterAccountDto registerAccountModel)
{
ToastSuccess("注册成功，即将自动登录...");
var loginModel = new LoginModel
{
Password = registerAccountModel.Password,
Username = registerAccountModel.UserAccount
};
var loginResult = await authenticationService.Login(loginModel);
if (loginResult.Successful)
{
await NavigateToReturnUrl();
}
else
{
foreach (var item in loginResult.Errors)
{
ToastError(item);
}
}
}
public async Task RegisterAccountAsync(RegisterAccountDto registerAccountDto)
{
ValidatorUserService.ValidatorRoleName(registerAccountDto);
ValidatorUserService.ValidatorUserName(registerAccountDto);
ValidatorUserService.ValidatorPassword(registerAccountDto);
ValidatorUserService.ValidatorUserEmail(registerAccountDto);
var user = await this.context.Users
.Where(name => name.UserName == registerAccountDto.UserName)
.Select(username => username.UserName)
.SingleOrDefaultAsync();
ValidatorUserService.ValidatorForExistUsername(user, registerAccountDto);
var passwordHasher = new PasswordHasher <User>();
var account = new User
{
UserName = registerAccountDto.UserName,
NormalizedUserName = registerAccountDto.UserName.ToUpper(),
LockoutEnabled = true,
Email = registerAccountDto.Email,
NormalizedEmail = registerAccountDto.Email.ToUpper()
};
account.PasswordHash = passwordHasher.HashPassword(account, registerAccountDto.Password);
await this.userManager.CreateAsync(account);
await this.userManager.AddToRoleAsync(account, registerAccountDto.Role);
var currentUser = await this.context.Users
.Where(userId => userId.Id == registerAccountDto.CurrentUserId)
.Select(uName => uName.UserName)
.SingleOrDefaultAsync();
logger.LogInformation($"New user {registerAccountDto.UserName} registered by {currentUser}");
}
public async Task ThrowException_IfUsernameIsТaken()
{
var username = "******";
var password = "******";
var email = "TestEmail";
var role = "TestRole";
var loggerMock = new Mock <ILogger <UserService> >().Object;
var options = TestUtilities.GetOptions(nameof(ThrowException_IfUsernameIsТaken));
using (var actContext = new E_MailApplicationsManagerContext(options))
{
var user = await actContext.Users.AddAsync(
new User
{
UserName = username,
NormalizedUserName = username.ToUpper(),
LockoutEnabled = true
});
await actContext.SaveChangesAsync();
var accountDto = new RegisterAccountDto
{
UserName = username,
Password = password,
Role = role,
Email = email
};
var accountService = new UserService(actContext, null, loggerMock);
await accountService.RegisterAccountAsync(accountDto);
}
}
