public async Task RegisterNewUser()
{
UserSignUpDTO newUser = new UserSignUpDTO()
{
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var serializedNewUser = JsonConvert.SerializeObject(newUser);
var signUpContent = new StringContent(serializedNewUser, Encoding.UTF8, "application/json");
var addUser = await _client.PostAsync("/api/v1/users/signUp", signUpContent);
var addUserResponseString = await addUser.Content.ReadAsStringAsync();
var userId = JsonConvert.DeserializeObject <long>(addUserResponseString);
var getUser = await _client.GetAsync("/api/v1/users/" + userId);
var getUserResponseString = await getUser.Content.ReadAsStringAsync();
var userResult = JsonConvert.DeserializeObject <User>(getUserResponseString);
Assert.Equal(HttpStatusCode.OK, addUser.StatusCode);
Assert.Equal(newUser.UserName, userResult.UserName);
Assert.Equal(newUser.Email, userResult.Email);
}
public UserSignUpResponseDTO UserSignUp(UserSignUpRequestDTO userSignUpRequestDTO)
{
_logger.LogInformation("UserSignUp email:" + userSignUpRequestDTO.Email);
UserSignUpDTO userSignUpDTO = _mapper.Map <UserSignUpDTO>(userSignUpRequestDTO);
UserSignUpResultDTO userSignUpResultDTO = _userService.UserSignUp(userSignUpDTO);
UserSignUpResponseDTO userSignUpResponseDTO = _mapper.Map <UserSignUpResponseDTO>(userSignUpResultDTO);
return(userSignUpResponseDTO);
}
public async Task <IActionResult> SignUp([FromBody] UserSignUpDTO user)
{
try
{
return(Ok(await _usersRepository.AddUser(user)));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> SignUp(UserSignUpDTO userSignDTO)
{
var user = _mapper.Map <UserSignUpDTO, User>(userSignDTO);
var userCreateResult = await _userManager.CreateAsync(user, userSignDTO.Password);
if (userCreateResult.Succeeded)
{
return(Created(string.Empty, string.Empty));
}
return(Problem(userCreateResult.Errors.First().Description, null, 500));
}
public async Task <ActionResult <WebApiResponse> > SignUp([FromBody] UserSignUpDTO userDTO)
{
ISignupModelUser signupModelUser = new SignupModelUser()
{
Username = userDTO.Username,
Password = userDTO.Password,
Email = userDTO.Email,
Name = userDTO.Name,
MiddleName = userDTO.MiddleName
};
string cloudIdentityId = await _authentication.SignUpUser(signupModelUser);
return(await((IUserComponent)_contextCRUD).CreateUserAndUserAccountsAsync(userDTO, cloudIdentityId));
}
public async Task When_SignUp_Success()
{
UserSignUpDTO fakeData = new UserSignUpDTO
{
Username = _faker.Person.UserName,
Name = _faker.Person.FirstName,
MiddleName = _faker.Person.LastName,
Email = _faker.Internet.Email(),
Password = "******"
};
var response = await Helpers.ApiHelper.SendPostRequestAndGetResponse <UserSignUpDTO>(
_webClient, SignupUrl, fakeData);
Assert.AreEqual(expected: 200, actual: (int)response.StatusCode);
}
public UserSignUpResponseDTO UserSignUp(UserSignUpRequestDTO userSignUpRequestDTO)
{
_logger.LogInformation("UserSignUp email:" + userSignUpRequestDTO.Email);
UserSignUpDTO userSignUpDTO = new UserSignUpDTO {
FirstName = userSignUpRequestDTO.First_name,
LastName = userSignUpRequestDTO.Last_name,
Phone = userSignUpRequestDTO.Phone,
Company = userSignUpRequestDTO.Company,
Position = userSignUpRequestDTO.Position,
Locality = userSignUpRequestDTO.Locality,
Email = userSignUpRequestDTO.Email,
Password = userSignUpRequestDTO.Password
};
UserSignUpResultDTO userSignUpResultDTO = _userService.UserSignUp(userSignUpDTO);
UserSignUpResponseDTO userSignUpResponseDTO = _mapper.Map <UserSignUpResponseDTO>(userSignUpResultDTO);
return(userSignUpResponseDTO);
}
public async Task <IActionResult> SignUp([FromBody] UserSignUpDTO user)
{
ApplicationUser appUser = Mapper.Map <UserSignUpDTO, ApplicationUser>(user);
appUser.UserName = user.Email;
IdentityResult result = await _userManager.CreateAsync(appUser, user.Password);
if (result == IdentityResult.Success)
{
await _signInManager.SignInAsync(appUser, false);
string token = GenerateAccessToken(appUser);
return(Ok(token));
}
else
{
throw new Exception("Sign-Up Failed");
}
}
public UserSignUpResultDTO UserSignUp(UserSignUpDTO userSignUpDTO)
{
_logger.LogInformation("UserSignUp email:" + userSignUpDTO.Email);
string passwordRaw = userSignUpDTO.Password;
AuthHashResultDTO authHashResultDTO = _authService.Hash(passwordRaw);
Account account = new Account {
Id = userSignUpDTO.Email,
PasswordHash = authHashResultDTO.ValueHash,
PasswordSalt = authHashResultDTO.ValueSalt
};
_dbContext.Accounts.Add(account);
User user = new User {
Account = account
};
_dbContext.Users.Add(user);
_dbContext.SaveChanges();
return(new UserSignUpResultDTO());
}
public async Task <object> Register(UserSignUpDTO usr)
{
#region CheckEmailExist
if (await _context.Users.AnyAsync(u => u.Email == usr.Email))
{
ModelState.AddModelError("Exist email", "This email had been registered");
}
#endregion
#region CheckPasswordIsInvalid
if (!PasswordValid.Valid(usr.Password))
{
ModelState.AddModelError("Password", PasswordValid.Message);
}
#endregion
#region CheckModelIsInvalid
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
#endregion
usr.Password = CryptoHelper.Crypto.HashPassword(usr.Password);
User user = new User();
try
{
user = _mapper.Map <User>(usr);
user.CreatedAt = DateTime.UtcNow.AddHours(4);
await _context.Users.AddAsync(user);
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(StatusCode(409));
}
return(Ok(_mapper.Map <UserGetDTO>(user)));
}
public async Task <long> AddUser(UserSignUpDTO user)
{
var userInDb = _context.Users.Where(x => x.UserName.Equals(user.UserName) || x.Email.Equals(user.Email)).FirstOrDefault();
if (userInDb != null)
{
throw new Exception("User already exists"); // coś tu nie do końca działa
}
string hashedPwd = BCrypt.Net.BCrypt.HashPassword(user.Password);
User entityUser = new User()
{
UserName = user.UserName,
Email = user.Email,
PasswordHash = hashedPwd,
Role = "User"
};
var result = await _context.AddAsync <User>(entityUser);
await _context.SaveChangesAsync();
return(result.Entity.UserId);
}
public async Task <ActionResult <WebApiResponse> > CreateUserAndUserAccountsAsync(UserSignUpDTO userDTO, string cloudIdentityId)
{
User userEntity = new User()
{
Username = userDTO.Username,
Email = userDTO.Email,
CloudIdentityId = cloudIdentityId,
};
await AppDbContext.BeginTransactionAsync();
User user = await CreateFromEntityAsync(userEntity);
await CreateUserAccountsAsync(user);
await AppDbContext.CommitTransactionAsync();
return(new WebApiResponse().Success());
}
