public async Task RegisterNormalAsync_Returns_Failed_RegisterResultDto()
{
//Arrange
var newUser = new RegisterAdminDto
{
FirstName = "New Admin",
LastName = "Access",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
_fixture.MockUserManager.Setup(x => x.FindByNameAsync(newUser.Email))
.ReturnsAsync(_fixture.Users.FirstOrDefault(d => d.Email == newUser.Email) !);
_fixture.MockUserManager.Setup(x => x.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Failed(new IdentityErrorDescriber().PasswordTooShort(4))).Verifiable();
_fixture.MockUserManager.Setup(x => x.AddToRolesAsync(It.IsAny <User>(), It.IsAny <IEnumerable <string> >()));
var repository = new AccountRepository(AutoMapperSingleton.Mapper, _fixture.MockUserManager.Object,
_fixture.MockJwtTokenService.Object, _fixture.MockUserAccessorService.Object);
//Act
var result = await repository.RegisterAdminAsync(newUser);
//Assert
var registerResult = result.Should().BeAssignableTo <RegisterResultDto>().Subject;
registerResult.Status.Should().Be("Failed");
registerResult.Message.Should().Be("Failed to create new user. Error: (Passwords must be at least 4 characters.)");
}
public async Task <RegisterResultDto> RegisterAdminAsync(RegisterAdminDto registerDto)
{
var dbUser = await _userManager.FindByNameAsync(registerDto.Email);
if (dbUser != null)
{
throw new RestException(HttpStatusCode.Conflict, $"Email {registerDto.Email} is already registered.");
}
var user = _mapper.Map <User>(registerDto);
var result = await _userManager.CreateAsync(user, registerDto.Password);
if (result.Succeeded)
{
await _userManager.AddToRolesAsync(user, new List <string> {
Roles.Admin.ToString()
});
}
return(new RegisterResultDto
{
Status = result.Succeeded ? "Success" : "Failed",
Message = result.Succeeded ? "User created successfully, grant Admin access." : $"Failed to create new user. Error: ({string.Join(", ", result.Errors.Select(x => x.Description))})"
});
}
public async Task RegisterAdminAsync_Throws_ConflictException()
{
//Arrange
var newUser = new RegisterAdminDto
{
FirstName = "New Admin",
LastName = "Access",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
_fixture.MockUserManager.Setup(x => x.FindByNameAsync(newUser.Email))
.ReturnsAsync(_fixture.Users.FirstOrDefault(d => d.Email == newUser.Email) !);
var repository = new AccountRepository(AutoMapperSingleton.Mapper, _fixture.MockUserManager.Object,
_fixture.MockJwtTokenService.Object, _fixture.MockUserAccessorService.Object);
//Act
var exception = await Assert.ThrowsAsync <RestException>(() => repository.RegisterAdminAsync(newUser));
//Assert
exception.ErrorCode.Should().Be(HttpStatusCode.Conflict);
exception.ErrorMessage.Should().Be("Email [email protected] is already registered.");
exception.ErrorType.Should().Be(HttpStatusCode.Conflict.ToString());
}
public async Task RegisterAdminAsync_Returns_Success_RegisterResultDto()
{
//Arrange
var newUser = new RegisterAdminDto
{
FirstName = "New Admin",
LastName = "Access",
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
_fixture.MockUserManager.Setup(x => x.FindByNameAsync(newUser.Email))
.ReturnsAsync(_fixture.Users.FirstOrDefault(d => d.Email == newUser.Email) !);
_fixture.MockUserManager.Setup(x => x.CreateAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(IdentityResult.Success).Verifiable();
_fixture.MockUserManager.Setup(x => x.AddToRolesAsync(It.IsAny <User>(), It.IsAny <IEnumerable <string> >()));
var repository = new AccountRepository(AutoMapperSingleton.Mapper, _fixture.MockUserManager.Object,
_fixture.MockJwtTokenService.Object, _fixture.MockUserAccessorService.Object);
//Act
var result = await repository.RegisterAdminAsync(newUser);
//Assert
var registerResult = result.Should().BeAssignableTo <RegisterResultDto>().Subject;
registerResult.Status.Should().Be("Success");
registerResult.Message.Should().Be("User created successfully, grant Admin access.");
}
public async Task <Result <AuthenticatedClientDto> > SignUpAdminAsync(RegisterAdminDto dto)
{
if (!_appSetting.AdminEmailAddress.Equals(dto.AdminEmailAddress, StringComparison.OrdinalIgnoreCase))
{
throw new BadRequestException("AdminEmailAddress", "ایمیل ادمین اشتباه می باشد");
}
if (!_passwordService.Verify(dto.RootPassword, _appSetting.RootPassword))
{
throw new BadRequestException("password", "پسوورد ادمین اشتباه می باشد.");
}
dto.Email = dto.Email.ToLower();
if (await _unitOfWork.Admins.AnyAsync(a => a.Email == dto.Email))
{
throw new BadRequestException("Email", "این ایمیل در سیستم وجود دارد");
}
if (!await _unitOfWork.Organizations.AnyAsync(a => a.Id == dto.OrganizationId))
{
throw new BadRequestException("OrganizationId", "سازمان وارد شده معتبر نمی باشد");
}
var admin = new Admin(new PersonName(dto.Name, dto.Lastname), dto.AdminType, dto.OrganizationId,
dto.PhoneNumber, dto.Number);
admin.Register(dto.Email, _passwordService.HashPassword(dto.Password));
await _unitOfWork.CompleteAsync(async ctx => { await _unitOfWork.Admins.AddAsync(admin); });
return(await SignInAdminAsync(new SignInDto
{
Password = dto.Password,
EmailOrPhoneNumber = dto.Email
}));
}
public RegisterAdminDtoValidatorFixture()
{
Validator = new RegisterAdminDtoValidator();
Model = new RegisterAdminDto
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******",
FirstName = "James",
LastName = "Vasanth"
};
}
public async Task <IActionResult> RegisterUserByAdmin(RegisterAdminDto request)
{
try
{
await _userService.RegisterUSerByAdmin(request);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <ApplicationUser> RegisterUSerByAdmin(RegisterAdminDto request)
{
return(await ProcessRequest(async() =>
{
if (request.Password != request.ConfirmPassword)
{
throw new AppException(_logger, "ConfirmPassword is not the same Password");
}
var userName = await _unitOfWork.User.FindByNameAsync(request.UserName);
if (userName != null)
{
throw new AppException(_logger, $"User Name: {request.UserName} is already taken");
}
var userEmail = await _unitOfWork.User.FindByEmailAsync(request.Email);
if (userEmail != null)
{
throw new AppException(_logger, $"User Email: {request.Email} is already taken");
}
if (!request.Dob.HasValue)
{
throw new AppException(_logger, "Date of birth is required");
}
var user = _mapper.Map <ApplicationUser>(request);
if (user == null)
{
throw new AppException(_logger, "Register Failed");
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(request.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
user.NormalizedUserName = request.UserName.ToUpper();
user.NormalizedEmail = request.Email.ToUpper();
user.SecurityStamp = Guid.NewGuid().ToString("D");
await _unitOfWork.User.CreateAsync(user);
var claims = new List <Claim>()
{
new Claim(ClaimTypes.GivenName, request.FirstName),
new Claim(ClaimTypes.Surname, request.LastName),
new Claim(ClaimTypes.Email, request.Email)
};
foreach (var claim in claims)
{
var userClaim = new ApplicationUserClaim()
{
UserId = user.Id,
ClaimType = claim.Type,
ClaimValue = claim.Value
};
await _unitOfWork.UserClaim.CreateAsync(userClaim);
}
await _unitOfWork.SaveAsync();
var listRoleModel = new ArrayList();
if (request.ListRoleName == null)
{
var role = new AddToRoleDto()
{
RoleName = "USER",
UserName = request.UserName
};
await _roleService.AddUserToRole(role);
}
else
{
foreach (var role in request.ListRoleName)
{
var roleModel = new AddToRoleDto()
{
UserName = request.UserName,
RoleName = role
};
listRoleModel.Add(roleModel);
}
}
if (listRoleModel == null)
{
throw new AppException(_logger, "Add Role Failed");
}
foreach (AddToRoleDto roleModel in listRoleModel)
{
await _roleService.AddUserToRole(roleModel);
}
return user;
}));
}
public async Task<IActionResult> RegisterAdmin(RegisterAdminDto registerDto)
{
var result = await _repository.RegisterAdminAsync(registerDto);
return Ok(result);
}
public AccountControllerFixture()
{
ApiVersion = new ApiVersion(1, 0);
MockAccountRepository = new Mock <IAccountRepository>();
HttpContext = new DefaultHttpContext();
Users = new List <GetUserDto>
{
new GetUserDto
{
Id = Guid.NewGuid(),
FirstName = "Anna",
LastName = "Domino",
Email = "*****@*****.**",
PhoneNumber = "",
Roles = new List <string> {
"SuperAdmin", "Admin", "Report", "Normal"
}
},
new GetUserDto
{
Id = Guid.NewGuid(),
FirstName = "Neil",
LastName = "Down",
Email = "*****@*****.**",
PhoneNumber = "",
Roles = new List <string> {
"Admin"
}
},
new GetUserDto
{
Id = Guid.NewGuid(),
FirstName = "Mark",
LastName = "Ateer",
Email = "*****@*****.**",
PhoneNumber = "",
Roles = new List <string> {
"Report", "Normal"
}
},
new GetUserDto
{
Id = Guid.NewGuid(),
FirstName = "Dave",
LastName = "Allippa",
Email = "*****@*****.**",
PhoneNumber = "",
Roles = new List <string> {
"Normal"
}
}
};
ValidLoginDto = new LoginDto
{
Email = "*****@*****.**",
Password = "******"
};
ValidRegisterAdminDto = new RegisterAdminDto
{
FirstName = "John",
LastName = "Quil",
ConfirmPassword = "******",
Password = "******",
Email = "*****@*****.**"
};
ValidRegisterNormalDto = new RegisterNormalDto
{
FirstName = "Rose",
LastName = "Bush",
ConfirmPassword = "******",
Password = "******",
Email = "*****@*****.**",
Roles = new List <string> {
"Report", "Normal"
}
};
ValidLoginDto = new LoginDto
{
Email = "*****@*****.**",
Password = "******"
};
ValidRefreshDto = new RefreshDto
{
RefreshToken = "this is refresh token"
};
ValidRevokeDto = new RevokeDto
{
RefreshToken = "this is refresh JWT token"
};
SuccessAdminRegisterResultDto = new RegisterResultDto
{
Status = "Success",
Message = "User created successfully, grant Admin access."
};
FailedRegisterResultDto = new RegisterResultDto
{
Status = "Failed",
Message = "Failed to create new user."
};
SuccessNormalRegisterResultDto = new RegisterResultDto
{
Status = "Success",
Message = $"User created successfully, grant {string.Join(", ", ValidRegisterNormalDto.Roles)} access."
};
ValidTokenResultDtoResult = new TokenResultDto
{
AccessToken = "this will be a JWT access token",
RefreshToken = "this will be a JWT refresh token",
};
CurrentUserDtoResult = new CurrentUserDto
{
FirstName = "Simon",
LastName = "Sais",
Email = "*****@*****.**",
Roles = new List <string> {
"SuperAdmin", "Admin"
},
FullName = "Simon Sais",
UserId = Guid.Parse("77d8500b-dd97-4b6d-ce43-08d8aa3916b9")
};
}
public async Task <Result <AuthenticatedClientDto> > SignUpAdmin([FromBody] RegisterAdminDto dto) => await _authService.SignUpAdminAsync(dto);
