public IActionResult Post(UsuarioCadastroModel model)
{
//verificando se os campos da model passaram nas validações
if (ModelState.IsValid)
{
try
{
var usuario = mapper.Map <Usuario>(model);
usuarioRepository.Inserir(usuario);
var result = new
{
message = "Usuário cadastrada com sucesso",
usuario
};
return(Ok(result)); //HTTP 200 (SUCESSO!)
}
catch (Exception e)
{
return(StatusCode(500, "Erro: " + e.Message));
}
}
else
{
//Erro HTTP 400 (BAD REQUEST)
return(BadRequest("Ocorreram erros de validação."));
}
}
public IActionResult Post(UsuarioCadastroModel model,
[FromServices] IUsuarioRepository usuarioRepository)
{
try
{
if (usuarioRepository.Get(model.Email) != null)
{
return(StatusCode(403, "Erro. O email informado já encontra-se cadastrado."));
}
var usuario = new Usuario();
usuario.Nome = model.Nome;
usuario.Email = model.Email;
usuario.Senha = MD5Service.Encrypt(model.Senha);
usuarioRepository.insert(usuario);
return(Ok("Usuário cadastrado com sucesso!"));
}
catch (Exception e)
{
//retornar 500 da api cai no error
return(StatusCode(500, e.Message));
}
}
public ActionResult CadastrarUsuario(UsuarioCadastroModel model)
{
if (ModelState.IsValid)
{
try
{
Usuario u = new Usuario() //entidade
{
Nome = model.Nome,
Login = model.Login,
Senha = Criptografia.GetMD5Hash(model.Senha),
DataCadastro = DateTime.Now
};
UsuarioData d = new UsuarioData(); //persistencia
d.Insert(u); //gravando na base de dados...
ViewBag.Mensagem = "Usuario " + u.Nome + ", cadastrado com sucesso.";
ModelState.Clear(); //limpar o conteudo do formulario
}
catch (Exception e)
{
ViewBag.Mensagem = e.Message;
}
}
return(View("Cadastro")); //page_load
}
public IActionResult Post(UsuarioCadastroModel model,
[FromServices] UsuarioRepository repository,
[FromServices] MD5Service service)
{
if (ModelState.IsValid)
{
if (repository.Consultar(model.Email) != null)
{
return(BadRequest("Erro. O email informado já encontra-se cadastrado."));
}
else
{
try
{
var usuario = new Usuario();
usuario.Nome = model.Nome;
usuario.Email = model.Email;
usuario.Senha = service.Encriptar(model.Senha);
usuario.DataCriacao = DateTime.Now;
repository.Inserir(usuario);
return(Ok("Usuário cadastrado com sucesso"));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
}
else
{
return(BadRequest());
}
}
public IActionResult Cadastro(UsuarioCadastroModel model,
[FromServices] UsuarioRepository usuarioRepository)
{
if (ModelState.IsValid)
{
try
{
if (usuarioRepository.GetByEmail(model.Email) != null)
{
throw new Exception
("O email informado já encontra-se cadastrado.");
}
var usuario = new Usuario();
usuario.Nome = model.Nome;
usuario.Email = model.Email;
usuario.Senha = model.Senha;
usuario.Permissao = (Permissao)model.Permissao;
usuarioRepository.Insert(usuario);
TempData["MensagemSucesso"] = $"Usuário {usuario.Nome}, cadastrado com sucesso.";
ModelState.Clear();
}
catch (Exception e)
{
TempData["MensagemErro"] = "Erro: " + e.Message;
}
}
return(View());
}
public IActionResult Post(UsuarioCadastroModel model,
[FromServices] UsuarioRepository usuarioRepository)
{
try
{
//verificar se o email informado já existe no banco de dados
if (usuarioRepository.GetByEmail(model.Email) != null)
{
//HTTP 403 -> Forbidden
return(StatusCode(403, "O email informado já encontra-se cadastrado."));
}
else
{
//cadastrar o usuario
var usuario = new Usuario();
usuario.Nome = model.Nome;
usuario.Email = model.Email;
usuario.Senha = Criptografia.MD5Encrypt(model.Senha);
usuario.DataCriacao = DateTime.Now;
usuarioRepository.Insert(usuario);
//HTTP 201 -> Sucesso, Criado!
return(StatusCode(201, "Usuário cadastrado com sucesso"));
}
}
catch (Exception e)
{
//HTTP 500 -> Internal Server Error
return(StatusCode(500, e.Message));
}
}
public void PreencherFormularioDeCadastro(UsuarioCadastroModel model)
{
var nome = webDriver.FindElement(By.CssSelector("#firstname"));
nome.Clear();
nome.SendKeys(model.Nome);
var sobrenome = webDriver.FindElement(By.CssSelector("#lastname"));
sobrenome.Clear();
sobrenome.SendKeys(model.Sobrenome);
var email = webDriver.FindElement(By.CssSelector("#email_address"));
email.Clear();
email.SendKeys(model.Email);
var senha = webDriver.FindElement(By.CssSelector("#password"));
senha.Clear();
senha.SendKeys(model.Senha);
var confirmaSenha = webDriver.FindElement(By.CssSelector("#confirmation"));
confirmaSenha.Clear();
confirmaSenha.SendKeys(model.Senha);
}
public IActionResult Post([FromBody] UsuarioCadastroModel model)
{
//verificar se o conteúdo do objeto está correto
//em relação às regras de validação
if (ModelState.IsValid)
{
try
{
//verificar se o email informado não existe na base de dados
if (unitOfWork.UsuarioRepository
.Get(u => u.Email.Equals(model.Email)) == null)
{
var usuario = Mapper.Map <Usuario>(model);
unitOfWork.UsuarioRepository.Add(usuario);
unitOfWork.SaveChanges();
return(Ok("Usuário cadastrado com sucesso."));
}
else
{
return(BadRequest($"O email '{model.Email}' já existe no sistema."));
}
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
else
{
return(BadRequest(ValidationUtil.GetErrors(ModelState)));
}
}
public UsuarioDTO Create(UsuarioCadastroModel model)
{
var usuario = mapper.Map <Usuario>(model);
usuarioDomainService.Create(usuario);
return(mapper.Map <UsuarioDTO>(usuario));
}
public override void Given()
{
// Arrange
model = new UsuarioCadastroModel
{
Nome = "Usuario Teste",
Login = "******",
Senha = "senhateste",
ConfirmacaoSenha = "senha teste"
};
}
public void Insert(UsuarioCadastroModel model)
{
var usuario = new Usuario();
usuario.Nome = model.Nome;
usuario.Login = model.Login;
usuario.Senha = model.Senha;
usuario.DataCriacao = DateTime.Now;
usuarioDomainService.Insert(usuario);
}
public IActionResult Post(UsuarioCadastroModel model,
[FromServices] IUsuarioApplicationService usuarioApplicationService)
{
try
{
usuarioApplicationService.Insert(model);
return(Ok("Usuário cadastrado com sucesso."));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
[Fact] //Método de teste
public void AcessoUsuario_LojaDeLivros()
{
//instanciando a classe TestSteps
var steps = new AcessoUsuarioSteps();
#region Cadastro do usuário
//Acessar a página de cadastro de usuário
steps.AcessarPaginaDeCadastro(urlCadastro);
//cadastrar um usuario
var modelCadastro = new UsuarioCadastroModel
{
Nome = "Raphael",
Sobrenome = "Augusto",
Email = $"raphael.augusto{new Random().Next(999999)}@gmail.com",
Senha = $"@Admin{new Random().Next(9999)}"
};
steps.PreencherFormularioDeCadastro(modelCadastro);
var resultCadastro = steps.RealizarCadastro();
//critério de teste
resultCadastro.Should().Contain("Obrigado por se registrar com LOJA EXEMPLO de Livros");
//fechar a sessão do usuário
steps.SairDoSistema();
#endregion
#region Autenticação do usuário
//acessar a página de autenticação
steps.AcessarPaginaDeAutenticacao(urlAutenticacao);
//autenticar o usuário
var modelAutenticacao = new UsuarioAutenticacaoModel
{
Email = modelCadastro.Email,
Senha = modelCadastro.Senha
};
steps.PreencherFormularioDeAutenticacao(modelAutenticacao);
var resultAutenticacao = steps.RealizarAutenticacao();
resultAutenticacao.Should().Contain($"Bem-vindo, {modelCadastro.Nome} {modelCadastro.Sobrenome}!");
steps.SairDoSistema();
#endregion
}
public IActionResult Post(UsuarioCadastroModel model)
{
try
{
var result = UsuarioApplicationService.Create(model);
return(Ok(new
{
Message = "Usuario cadastrado com sucesso.",
Usuario = result
}));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
private UsuarioCadastroModel CarregarModelCadastro()
{
UsuarioCadastroModel model = new UsuarioCadastroModel();
model.ListagemPermissao = new List <SelectListItem>();
PermissaoRep rep = new PermissaoRep();
foreach (Permissao p in rep.ListarTodos())
{
SelectListItem item = new SelectListItem();
item.Value = p.IdPermissao.ToString();
item.Text = p.Nome;
model.ListagemPermissao.Add(item);
}
return(model);
}
public IActionResult Post([FromBody] UsuarioCadastroModel model)
{
if (ModelState.IsValid)
{
try
{
appService.Insert(model);
return(Ok(UsuarioResource.UsuarioCadastradoSucesso));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
else
{
return(BadRequest());
}
}
public async Task <Resposta> CadastrarUsuarioAsync(UsuarioCadastroModel model, CancellationToken cancellationToken = default)
{
if (string.IsNullOrEmpty(model.Nome))
{
return(Resposta.Aviso("Nome do usuário não informado!"));
}
if (model.Nome.Length > 90)
{
return(Resposta.Aviso("Nome do perfil não pode conter mais que 90 carácteres!"));
}
var perfil = await _perfilRep.RecuperarAsync(model.Perfil);
var usuario = new Usuario(model.Nome, model.Email, model.Senha, perfil);
await _rep.IncluirAsync(usuario, cancellationToken);
return(Resposta.Sucesso($"Usuario {usuario.Nome} cadastrado com sucesso!", new { usuario.Id, usuario.Nome }));
}
public IActionResult Post(UsuarioCadastroModel model)
{
try
{
var usuarioDTO = _usuarioApplicationService.Create(model);
return(StatusCode(201, new
{
Message = "Usuário cadastrado com sucesso.",
Usuario = usuarioDTO
}));
}
catch (Exception e)
{
return(StatusCode(500, new
{
e.Message
}));
}
}
public ActionResult Cadastro(UsuarioCadastroModel model)
{
try
{
if (ModelState.IsValid)
{
if (model.Senha.Equals(model.SenhaConfirm))
{
UsuarioRep rep = new UsuarioRep();
if (!rep.HasName(model.Nome))
{
Criptografia c = new Criptografia();
Usuario u = new Usuario();
u.Permissao = new Permissao();
u.Nome = model.Nome;
u.Email = model.Email;
u.Senha = c.ToEncrypt(model.Senha);
u.Permissao.IdPermissao = model.IdPermissao;
rep.Insert(u);
ViewBag.Mensagem = "Usuario cadastrado com sucesso!";
ModelState.Clear();
}
else
{
ViewBag.Mensagem = "Este usuário já existe! Favor, criar outro...";
}
}
else
{
ViewBag.Mensagem = "Senhas não conferem.";
}
}
}
catch (Exception e)
{
ViewBag.Mensagem = e.Message;
}
return(View(CarregarModelCadastro()));
}
public IActionResult Post(UsuarioCadastroModel model)
{
//Verifica se os dados da model passaram nas regras de validação
if (ModelState.IsValid)
{
try
{
//verificar se o login informado existe no banco de dados
if (repository.ObterPorLogin(model.Login) != null)
{
return(StatusCode(400, "Login já encontra-se cadastrado, tente outro."));
}
else
{
Criptografia criptografia = new Criptografia();
Usuario usuario = new Usuario();
usuario.Nome = model.Nome;
usuario.Login = model.Login;
usuario.Senha = criptografia.MD5Encrypt(model.Senha);
usuario.DataCriacao = DateTime.Now;
//gravar no banco de dados
repository.Inserir(usuario);
//retornar status de sucesso 200 (OK)
return(StatusCode(200, $"Usuário {usuario.Nome}, cadastrado com sucesso. "));
}
}
catch (Exception e)
{
//retornar um status de erro 500 (Erro Interno do Servidor)
return(StatusCode(500, e.Message));
}
}
else
{
//retornar um status de erro 400 (Requisição inválida)
return(StatusCode(400, "Ocorreram erros de validação."));
}
}
public ActionResult Cadastro(UsuarioCadastroModel model)
{
try
{
if (ModelState.IsValid)
{
if (model.Senha.Equals(model.SenhaConfirm))
{
UsuarioRepositorio rep = new UsuarioRepositorio();
if (!rep.HasLogin(model.Login))
{
Criptografia c = new Criptografia();
Usuario u = new Usuario();
u.Nome = model.NomeUsr;
u.Login = model.Login;
u.Senha = c.EncriptarSenha(model.Senha);
u.DataCadastro = DateTime.Now;
rep.Insert(u);
ViewBag.Mensagem = "Usuario cadastrado com sucesso.";
ModelState.Clear();
}
else
{
ViewBag.Mensagem = "Login já cadastrado, por favor tente outro.";
}
}
else
{
ViewBag.Mensagem = "Senhas não conferem, por favor tente novamente.";
}
}
}
catch (Exception e)
{
//exibindo mensagem de erro..
ViewBag.Mensagem = e.Message;
}
return(View());
}
public UsuarioDTO Create(UsuarioCadastroModel model)
{
var usuario = new UsuarioEntity
{
Id = Guid.NewGuid(),
Nome = model.Nome,
Email = model.Email,
Senha = model.Senha,
DataCriacao = DateTime.Now
};
usuarioDomainService.Create(usuario);
return(new UsuarioDTO
{
Id = usuario.Id,
Nome = usuario.Nome,
Email = usuario.Email,
DataCriacao = usuario.DataCriacao
});
}
public UsuarioDTO Create(UsuarioCadastroModel model)
{
var usuarioLogado = _usuarioDomainService.GetByLogin(_user.Name);
if (usuarioLogado != null)
{
var perfil = _perfilDomainService.GetById(usuarioLogado.Id);
}
var usuario = new Usuario
{
Id = Guid.NewGuid(),
Nome = model.Nome,
Email = model.Email,
Senha = model.Senha,
Created = DateTime.Now,
Modified = DateTime.Now,
LastLogin = DateTime.Now,
Perfis = new List <Perfil>
{
new Perfil {
Perfis = Perfis.Administrador.ToString(),
Id = Guid.NewGuid(),
IdUsuario = Guid.NewGuid()
}
}
};
_usuarioDomainService.Create(usuario);
return(new UsuarioDTO
{
Id = usuario.Id,
Nome = usuario.Nome,
Email = usuario.Email,
Created = usuario.Created,
Modified = usuario.Modified,
LastLogin = usuario.LastLogin
});
}
public IActionResult Post(UsuarioCadastroModel model)
{
if (ModelState.IsValid)
{
try
{
//verificar se o email informado ja existe no banco de dados
if (usuarioRepository.Obter(model.Email) != null)
{
return(BadRequest("O email informado já encontra-se cadastrado."));
}
var usuario = new Usuario();
usuario.Nome = model.Nome;
usuario.Email = model.Email;
usuario.Senha = Criptografia.MD5Encrypt(model.Senha);
usuario.DataCriacao = DateTime.Now;
usuarioRepository.Inserir(usuario);
var result = new
{
mensagem = "Usuário cadastrado com sucesso."
};
return(Ok(result));
}
catch (Exception e)
{
return(StatusCode(500, "Ocorreu um erro: " + e.Message));
}
}
else
{
return(BadRequest("Ocorreram erros de validação."));
}
}
public IActionResult Cadastro(UsuarioCadastroModel model)
{
if (ModelState.IsValid)
{
var jsonContent = JsonSerializer.Serialize(model);
var postContent = new StringContent(jsonContent, Encoding.UTF8, "application/json");
using (var client = new HttpClient())
{
var post = client.PostAsync("https://localhost:44376/api/usuario", postContent).GetAwaiter().GetResult();
var retorno = post.Content.ReadAsStringAsync().GetAwaiter().GetResult();
if (!string.IsNullOrEmpty(retorno))
{
ViewBag.Message = retorno;
}
}
}
ModelState.Clear();
return(View());
}
public void Create(UsuarioCadastroModel model)
{
var usuario = mapper.Map <Usuario>(model);
usuarioDomainService.Create(usuario);
}
public async Task <IActionResult> Post([FromBody] UsuarioCadastroModel model, CancellationToken cancellationToken) => await ExecutarAsync(_usuarioService.CadastrarUsuarioAsync(model, cancellationToken), cancellationToken);
public void Insert(UsuarioCadastroModel model)
{
var usuario = mapper.Map <Usuario>(model);
domain.Insert(usuario);
}
