public async Task <object> Register(RegisterAccountCommand login)
{
var user = new ApiUser {
UserName = login.Email, Email = login.Email, FirstName = login.FirstName, LastName = login.LastName
};
var result = await _userManager.CreateAsync(user, login.Password);
if (!result.Succeeded)
{
throw new ArgumentException("Falha ao registrar usuário");
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
await _signInManager.SignInAsync(user, isPersistent : false);
var claims = new[]
{
new Claim(ClaimTypes.Name, login.Email)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(new Sha512(Environment.GetEnvironmentVariable("Password")).ToString()));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: Environment.GetEnvironmentVariable("Issuer"),
audience: Environment.GetEnvironmentVariable("Audience"),
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds);
return(new { token = new JwtSecurityTokenHandler().WriteToken(token) });
}
public async Task Register_ExpectSuccessResponse()
{
// Arrange
var command = new RegisterAccountCommand()
{
Login = "******",
Nickname = "AlexAnder",
Password = "******",
PasswordRepeat = "12345678asdf",
};
var mockCommandFactory = new Mock <ICommandFactory>();
mockCommandFactory.Setup(repo => repo.Execute(command))
.Returns(async() =>
{
var handler = new RegisterAccountCommandHandler(uow, mapper);
await handler.Execute(command);
});
var mockQueryFactory = new Mock <IQueryFactory>();
mockQueryFactory.Setup(repo => repo.ResolveQuery <AccountByLoginAndPasswordQuery>())
.Returns(() => new AccountByLoginAndPasswordQuery(uow));
// Act
var controller = new AccountController(mockCommandFactory.Object, mockQueryFactory.Object, mapper, new AccountApiService(mapper));
await controller.Register(command);
// Assert
Assert.Pass();
}
public async Task <IActionResult> Register([FromBody] RegisterAccountCommand account, CancellationToken token = default(CancellationToken))
{
ModelState.ThrowValidationExceptionIfInvalid <Account.Errors>();
await commandFactory.Execute(account);
return(StatusCode(201, new AuthDataDto(account.AuthToken)));
}
public ActionResult Register()
{
var command = new RegisterAccountCommand {
AccountId = Guid.NewGuid()
};
return(View(command));
}
public async Task <AuthInfoDto> Register(RegisterAccountCommand command)
{
await commandFactory.Execute(command);
var account = await queryFactory.ResolveQuery <AccountByLoginAndPasswordQuery>()
.Execute(command.Login, command.Password);
return(this.accountApiService.CreateAuthInfo(account));
}
public void CreateValidCommand()
{
_registerAccountCommand = new RegisterAccountCommand()
{
AccountId = Guid.NewGuid(),
Email = "*****@*****.**",
Password = "******"
};
CommandValidator.ValidationFailures(_registerAccountCommand).Should().BeEmpty();
}
public void CreateValidCommand()
{
_registerAccountCommand = new RegisterAccountCommand()
{
AccountId = Guid.NewGuid(),
Email = "*****@*****.**",
Password = "******"
};
CommandValidator.ValidationFailures(_registerAccountCommand).Should().BeEmpty();
}
public async Task <Guid> Register(string name, string email, CancellationToken cancellationToken)
{
var accountId = Guid.NewGuid();
var registerAccountCommand = new RegisterAccountCommand()
{
Name = name,
Email = email,
AccountId = accountId
};
await _commandHandler.Handle(registerAccountCommand, cancellationToken);
return(accountId);
}
public async Task <IActionResult> loginAccount([FromBody] RegisterAccountCommand command)
{
bool commandResult = false;
try
{
commandResult = true;
}
catch (System.Exception ex)
{
throw;
}
return(commandResult ? (IActionResult)Ok() : (IActionResult)BadRequest());
}
public void RegisterAccount_ExpectConflictException()
{
// Arrange
var account = new RegisterAccountCommand()
{
Login = "******",
Password = "******",
PasswordRepeat = "12345678asdf"
};
var handler = new RegisterAccountCommandHandler(uow);
disposables.Add(handler);
// Assert
Assert.ThrowsAsync <ConflictException>(async() => await handler.Execute(account));
}
public async Task <IActionResult> registerAccount([FromBody] RegisterAccountCommand command)
{
bool commandResult = false;
try
{
RegisterUser teste = new RegisterUser();
await _mediator.Send(command);
commandResult = true;
}
catch (System.Exception ex)
{
throw;
}
return(commandResult ? (IActionResult)Ok() : (IActionResult)BadRequest());
}
public async Task RegisterAccount_ExpectSuccessResponse()
{
// Arrange
var account = new RegisterAccountCommand()
{
Login = "******",
Password = "******",
PasswordRepeat = "12345678asdf"
};
var handler = new RegisterAccountCommandHandler(uow);
disposables.Add(handler);
// Act
var result = await handler.Execute(account);
// Assert
Assert.AreEqual(1, result);
}
public ActionResult Register()
{
var command = new RegisterAccountCommand {AccountId = Guid.NewGuid()};
return View(command);
}
public async Task <ActionResult <string> > RegisterAccount(RegisterAccountCommand command)
{
return(await Mediator.Send(command));
}
public void Handle(RegisterAccountCommand command)
{
var account = new Account(command.AccountId, command.Name, command.Email, command.InitialBalance);
_repository.Save(account);
}
public async Task <ActionResult> Register(RegisterAccountCommand command)
{
var res = await Mediator.Send(command);
return(GetActionResult((Response)res));
}
public ActionResult Register(RegisterAccountCommand command)
{
Configuration.Instance().Bus.Handle(command);
return(View("Registered"));
}
public async Task <IActionResult> Register([FromBody] RegisterAccountCommand command)
{
return(await Publish(command));
}
public Task RegisterAccount(
[FromBody] RegisterAccountCommand request,
CancellationToken ct = default)
{
return(_mediator.Send(request, ct));
}
public ActionResult Register(RegisterAccountCommand command)
{
Configuration.Instance().Bus.Handle(command);
return View("Registered");
}
