public async Task <ICommandResult> Handle(CreateUserCommand request, CancellationToken cancellationToken)
{
request.Validate();
if (!request.IsValid)
{
return(new CommandResult(false, "Os dados do usuário estão incorretos.", request.Notifications));
}
var usuarioJaCadastrado = await _userRepository.VerifyUserAsync(request.UserCode);
if (usuarioJaCadastrado)
{
return(new CommandResult(true, "Usuario Já cadastrado", "cadastrado"));
}
var provedor = request.Email.Split("@");
var email = new Email(request.Email, provedor[1]);
var novoUsuario = new User(request.Name, email, request.UserCode, request.ShoppingDay);
var usuarioCadastrado = await _userRepository.CreateUserAsync(novoUsuario);
if (usuarioCadastrado == null)
{
return(new CommandResult(false, "Problemas ao efetuar o cadastro do usuário.", null));
}
var createUserDomainEvent = new UserOperationDomainEvent(EventAction.INSERT, novoUsuario);
await _domainEntityEventHandler.Raise(createUserDomainEvent);
return(new CommandResult(true, "Usuário cadastrado com sucesso!", request));
}
public void DadoUmLoginComSenhaMenorQue3_IsInvalid()
{
var command = new CreateUserCommand("usuario", "12", "12");
command.Validate();
Assert.AreEqual(command.Invalid, true);
}
public void DadoUmLoginComSenhasDiferentes_IsInvalid()
{
var command = new CreateUserCommand("usuario", "123", "123456");
command.Validate();
Assert.AreEqual(command.Invalid, true);
}
public void DadoUmLoginValido_IsValid()
{
var command = new CreateUserCommand("usuario", "123456", "123456");
command.Validate();
Assert.AreEqual(command.Valid, true);
}
public void DadoUmUsuarioSemEmail_Invalid()
{
var command = new CreateUserCommand("", "123456", "123456");
command.Validate();
Assert.AreEqual(command.Invalid, true);
}
public void DadoUmUsuarioComSenhasDiferentes_Invalid()
{
var command = new CreateUserCommand("*****@*****.**", "1234", "123456");
command.Validate();
Assert.AreEqual(command.Invalid, true);
}
public void DadoUmUsuarioComSenhaPequena_Invalid()
{
var command = new CreateUserCommand("*****@*****.**", "12", "12");
command.Validate();
Assert.AreEqual(command.Invalid, true);
}
public void DadoUmLoginUsuarioBranco_IsInvalid()
{
var command = new CreateUserCommand("", "1234", "1234");
command.Validate();
Assert.AreEqual(command.Invalid, true);
}
public void DadoUmUsuarioValido_Valid()
{
var command = new CreateUserCommand("*****@*****.**", "123456", "123456");
command.Validate();
Assert.AreEqual(command.Valid, true);
}
public ICommandResult CreateUser(CreateUserCommand command)
{
command.Validate();
if (!command.Valid)
{
return(new CommandResult(success: false, message: null, data: command.Notifications));
}
return(_handler.Handle(command));
}
public void ShouldReturnSuccessWhenUsernameIsValid()
{
var command = new CreateUserCommand
{
Username = "******"
};
command.Validate();
command.Valid.Should().BeTrue();
}
public void ShouldReturnErrorWhenUsernameLenghtIsGreaterThan32()
{
var command = new CreateUserCommand
{
Username = "******"
};
command.Validate();
command.Invalid.Should().BeTrue();
}
public void ShouldReturnErrorWhenUsernameIsNull()
{
var command = new CreateUserCommand
{
Username = null
};
command.Validate();
command.Invalid.Should().BeTrue();
}
public void ShouldReturnErrorWhenUsernameIsWhiteSpace()
{
var command = new CreateUserCommand
{
Username = "******"
};
command.Validate();
command.Invalid.Should().BeTrue();
}
public ICommandResult Handle(CreateUserCommand command)
{
command.Validate();
if (!command.IsValid)
{
return(new GenericCommandResult(false, "Error: ", command.Notifications));
}
var user = new User(command.Name, command.Email, command.Login, command.Password);
_repository.Create(user);
return(new GenericCommandResult(true, "Create user with success!", user));
}
public async Task <ResponseApi> Handle(CreateUserCommand request, CancellationToken cancelationToken)
{
try
{
request.Validate();
if (request.Invalid)
{
return(new ResponseApi(false, "Ops, something is wrong...", request.Notifications));
}
//var userExists = _userRepository.GetUserByFiscalNr(request.FiscalNr);
//if (userExists != null)
// return new ResponseApi(false, "User already exists.", userExists);
User user = _mapper.Map <User>(request);
await _userRepository.Insert(user);
var response = new UserViewModel
{
Id = user.Id,
Name = user.Name,
LastName = user.LastName,
FiscalNr = user.FiscalNr,
Email = user.Email,
BirthDay = user.BirthDay,
Gender = user.Gender,
Phone = user.Phone,
Street = user.Street,
StateProvince = user.StateProvince,
City = user.City,
Country = user.Country,
CityOfBirth = user.CityOfBirth,
ExperienceTime = user.ExperienceTime,
Summary = user.Summary,
Active = user.Active,
Excluded = user.Excluded,
CreationDate = user.CreationDate
};
return(new ResponseApi(true, "User created sucessfuly", response));
}
catch (Exception e)
{
return(new ResponseApi(false, "Error...", e));
}
}
public ICommandResult Handle(CreateUserCommand command)
{
command.Validate();
if (command.Invalid)
{
return(new GenericCommandResult(false, "Algo deu errado!", command.Notifications));
}
var user = new UserAccount
(
command.User
);
_repository.Create(user);
return(new GenericCommandResult(true, "O usuário foi criado!", user));
}
public ICommandResult Handle(CreateUserCommand command)
{
// Fail Fast Validation
command.Validate();
if (command.Invalid)
{
return(new GenericCommandResult(false, "Não foi possível criar o usuário!", command.Notifications));
}
var valEmail = _userRepository.GetByEmail(command.Email);
if (valEmail != null)
{
return(new GenericCommandResult(false, "Não foi possível criar o usuário, e-mail já existente!", command.Notifications));
}
var searchTemperature = _temperature.GetTemperatureCity(command.City);
if (searchTemperature == null)
{
return(new GenericCommandResult(false, "Não foi possível criar o usuário, verifique a cidade!", command.Notifications));
}
// Criptografa a Password e Personal Notes
var cryptUserPersonalNotes = _encryption.Encrypt(command.PersonalNotes);
var cryptUserPassword = _encryption.Encrypt(command.Password);
var user = new User(command.Name, command.Email, cryptUserPassword, command.City, cryptUserPersonalNotes);
// Salva no banco
_userRepository.Create(user);
// Busca musicas para recomendar
object playList = ReturnPlayListByTemperature(searchTemperature);
// Transita apenas os dados necessários
var userDto = new UserDto(user.Id, user.Name, user.Email, user.City, command.PersonalNotes, searchTemperature, playList);
return(new GenericCommandResult(true, "Usuário criado", userDto));
}
public static User Create(CreateUserCommand command)
{
command.Validate(true);
var user = new User
{
Name = command.Name,
Login = command.Login,
Email = command.Email,
Country = command.Country,
Currency = command.Currency,
IdentityServerId = command.IndentityServerId,
roles = command.UserRoles.Select(r => new UserRole
{
Role = r.Role,
Accounts = r.GrantedAccounts?.ToList(),
Organisations = r.GrantedOrganisations?.ToList()
}).ToList()
};
return(user);
}
public CreateUserHandlerTests()
{
_validCommand.Validate();
_invalidCommand.Validate();
_nullCommand.Validate();
}
public CreateUserCommandTest()
{
_validCommand.Validate();
_invalidCommand.Validate();
_nullCommand.Validate();
}
public CreateUserCommandTests()
{
_invalidCommand.Validate();
_validCommand.Validate();
}
