public async Task <ActionResult> Register(AccountRegisterDto model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (await accountRepository.GetByUsernameAsync(model.Username) != null)
{
ModelState.AddModelError(nameof(model.Username), $"Korisničko ime '{model.Username}' je zauzeto");
return(View(model));
}
if (await accountRepository.GetByEmailAsync(model.Email) != null)
{
ModelState.AddModelError(nameof(model.Email), $"Email adresa '{model.Email}' je zauzeta");
return(View(model));
}
var newAccount = new Account
{
Email = model.Email,
Username = model.Username,
PasswordHash = passwordHasher.HashPassword(model.Password)
};
await accountRepository.AddAsync(newAccount);
return(RedirectToAction("Login"));
}
public void Register_Should_ThrowValidationException_When_IbanNumberIsInvalid(string ibanNumber)
{
var dto = new AccountRegisterDto
{
iban_number = ibanNumber,
acccount_name = "My name is Hero"
};
Assert.ThrowsAsync <ValidationException>(() => _testService.Register(dto));
}
public void Register_Should_ThrowValidationException_When_AccontNameIsInvalid(string accountName)
{
var dto = new AccountRegisterDto
{
iban_number = "NL13ABNA7035378898",
acccount_name = accountName
};
MockAccountRepository.Setup(x => x.IsUniqueIbanNumber(It.IsAny <string>())).Returns(Task.FromResult(true));
Assert.ThrowsAsync <ValidationException>(() => _testService.Register(dto));
}
public void Register_Should_ThrowValidationException_When_IbanNumberAlreadyExists()
{
var dto = new AccountRegisterDto
{
iban_number = "NL13ABNA7035378898",
acccount_name = "My name is Hero"
};
MockAccountRepository.Setup(x => x.IsUniqueIbanNumber(It.IsAny <string>())).Returns(Task.FromResult(false));
Assert.ThrowsAsync <ValidationException>(() => _testService.Register(dto));
}
public async Task <AccountDto> Register(AccountRegisterDto dto)
{
ValidationHelper.Validate(_accountRegisterValidator, dto);
var entity = new Account
{
AccountName = dto.acccount_name,
IBanNumber = dto.iban_number,
RegisterDate = DateTime.Now,
};
await _accountRepository.Add(entity);
return(ConvertToDto(entity));
}
public void Register_Should_Success_When_DtoIsValid()
{
var dto = new AccountRegisterDto
{
iban_number = "NL13ABNA7035378898",
acccount_name = "My name is Hero"
};
MockAccountRepository.Setup(x => x.IsUniqueIbanNumber(It.IsAny <string>())).Returns(Task.FromResult(true));
MockAccountRepository.Setup(x => x.Add(It.IsAny <Account>())).Returns(Task.FromResult(new Account()));
var result = _testService.Register(dto).Result;
Assert.IsNotNull(result);
}
public async Task <IActionResult> Register([FromBody] AccountRegisterDto registerDto)
{
var user = _mapper.Map <User>(registerDto);
var result = await _userManager.CreateAsync(user, registerDto.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _signInManager.SignInAsync(user, false);
var accessToken = GenerateJwtToken(user.Id, user.Email);
var refreshToken = await GenerateRefreshToken(user.Id);
return(Ok(new AccountTokenDto
{
AccessToken = accessToken,
RefreshToken = refreshToken.Token
}));
}
public async Task <bool> Register(AccountRegisterDto dto)
{
try
{
Guid Userid = Guid.NewGuid();
Guid ProfileId = Guid.NewGuid();
RoleDto defaultRole = await GetRole("Default");
using (DHContext db = new DHContext())
{
Profile profile = new Profile
{
Id = ProfileId,
FirstName = string.Empty,
Gender = string.Empty,
LastName = string.Empty,
MiddleName = string.Empty,
UserId = Userid
};
User user = new User
{
Login = dto.Login,
Id = Userid,
RoleId = defaultRole.Id,
HashPassword = HashPassword(dto.Password),
ProfileId = ProfileId
};
db.Users.Add(user);
db.Profiles.Add(profile);
await db.SaveChangesAsync();
}
return(true);
}
catch (Exception exc)
{
_logger.Error($"Failed register new user {dto.Login} : {exc}");
return(false);
}
}
public async Task <IActionResult> Register([FromBody] AccountRegisterDto model)
{
var registerRequest = model.Adapt <RegisterDto>();
var registerResponse = await _registerService.Register(registerRequest);
if (!registerResponse.Success)
{
return(Problem("Error Registering user on Identity"));
}
model.Id = registerResponse.UserId;
_userProfileService.Add(model);
var loginRequest = model.Adapt <LoginDto>();
var loginResponse = await _loginService.Login(loginRequest);
if (!registerResponse.Success)
{
return(Problem());
}
return(Ok(loginResponse));
}
public async Task <JsonResult> Register(AccountRegisterDto dto)
{
var result = await _accountService.Register(dto);
return(Json(result, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult <AccountDto> > Post(AccountRegisterDto dto)
{
var viewDto = await _accountService.Register(dto);
return(CreatedAtAction("Get", new { ibanNumber = viewDto.iban_number }, viewDto));
}
