public async Task <ResponseDTO> Add(UsuarioAddDTO usuario)
{
var response = new ResponseDTO();
try
{
var obj = _mapper.Map <Usuario>(usuario);
if (obj.Anonimo)
{
obj.Nome = "Anonimo " + Guid.NewGuid();
var result = await _usuarioService.Add(obj);
response.Sucesso = (result > 0) ? true : false;
response.Mensagem = "Usuario Inserido com Sucesso.";
response.Data = new
{
Id = obj.Id
};
}
else
{
if (!_usuarioService.ExisteNome(obj.Nome))
{
var result = await _usuarioService.Add(obj);
response.Sucesso = (result > 0) ? true : false;
response.Mensagem = "Usuario Inserido com Sucesso.";
response.Data = new
{
Id = obj.Id
};
}
else
{
response.Sucesso = false;
response.Mensagem = "Nome ou Apelido já existente.";
}
}
return(response);
}
catch
{
response.Sucesso = false;
response.Mensagem = "Ocorreu um Erro com Servidor. Contate a equipe de TI.";
return(response);
}
}
public void Add(UsuarioViewModel usuario)
{
var usuarioEntity = _mapper.Map <Usuario>(usuario);
usuarioEntity.Id = Guid.NewGuid().ToString();
_usuarioService.Add(usuarioEntity);
}
private async Task TesteValidacaoUsuarioJaCadastradoAsync()
{
IUsuarioService service = serviceProvider.GetRequiredService <IUsuarioService>();
Usuario usuarioNovo = null;
try
{
Usuario usuario = new Usuario();
usuario.Nome = $"Usuário de teste2";
usuario.Login = "******";
usuario.Password = DomainHelper.CalculateMD5Hash("teste2");
usuario.Setor = UsuarioSetor.Cozinha;
usuarioNovo = await service.Add(usuario);
service.Result.Any().Should().BeFalse();
await CadastrarNovoUsuarioCoMesmoLogin();
}
finally
{
if (usuarioNovo != null)
{
bool resultadoExclusao = await service.Delete(usuarioNovo.Id);
resultadoExclusao.Should().BeTrue();
}
}
}
public async Task <Usuario> Add(Usuario usuario)
{
if (usuario == null)
{
throw new Exception("Informe o usuário.");
}
else if (string.IsNullOrEmpty(usuario?.Nome.Trim()))
{
throw new Exception("O campo \"Nome\" é obrigatório.");
}
else if (usuario.Nome.Trim().Length < 3)
{
throw new Exception("O campo \"Nome\" precisa ter no mínimo 3 caracteres.");
}
else if (usuario.Nascimento.Equals(default(DateTime)))
{
throw new Exception("O campo \"Nascimento\" é obrigatório.");
}
else if (usuario.SexoId <= 0 && usuario.SexoId > 2)
{
throw new Exception("Informe um \"Sexo\". (Feminino ou Masculino).");
}
return(await _usuarioService.Add(usuario));
}
public UsuarioViewModel Add(UsuarioViewModel obj)
{
var modelUsuario = _mapper.Map <Usuario>(obj);
var usuario = _usuarioService.Add(modelUsuario);
return(_mapper.Map <UsuarioViewModel>(usuario));
}
public IActionResult Post([FromBody] UsuarioModel usuario)
{
if (_service.Add(usuario))
return Ok(usuario);
return null;
}
public UsuarioViewModel Add(UsuarioViewModel obj)
{
var model = _mapper.Map <Usuario>(obj);
model = _usuarioService.Add(model);
return(_mapper.Map <UsuarioViewModel>(model));
}
public UsuarioViewModel Add(UsuarioViewModel obj)
{
var topico = Mapper.Map <UsuarioViewModel, Usuario>(obj);
BeginTransaction();
_usuarioService.Add(topico);
Commit();
return(obj);
}
public UsuarioViewModel Add(UsuarioViewModel usuarioViewModel)
{
Usuario novoUsuario = Mapper.Map <UsuarioViewModel, Usuario>(usuarioViewModel);
_usuarioService.Add(novoUsuario);
usuarioViewModel = Mapper.Map <Usuario, UsuarioViewModel>(novoUsuario);
return(usuarioViewModel);
}
private async Task <Usuario> ObterUsuario(IUsuarioService service)
{
Usuario usuario = new Usuario();
usuario.Nome = $"Usuário de teste";
usuario.Login = "******";
usuario.Password = DomainHelper.CalculateMD5Hash("teste");
usuario.Setor = UsuarioSetor.Cozinha;
return(await service.Add(usuario));
}
public ActionResult Create([Bind(Include = "Id,NomeUsuario,Senha")] Usuario usuario)
{
if (ModelState.IsValid)
{
_usuarioService.Add(usuario);
return(RedirectToAction("Index"));
}
return(View(usuario));
}
public async Task <IActionResult> Add(UsuarioRequest request)
{
var usuario = _mapper.Map <Usuario>(request);
await _service.Add(usuario);
var usuarioDto = _mapper.Map <UsuarioDto>(usuario);
var respose = new ApiResponse <UsuarioDto>(usuarioDto);
return(Ok(respose));
}
public IActionResult PostUsuarioViewModel(UsuarioViewModel UsuarioViemModel)
{
if (!ModelState.IsValid)
{
return(Response(UsuarioViemModel));
}
_usuarioService.Add(UsuarioViemModel);
return(Response(UsuarioViemModel));
}
public async Task <UsuarioDTO> Add(UsuarioDTO objeto)
{
objeto.Senha = RetornarMD5(objeto.Senha).Result.ToString();
var map = _mapper.Map <UsuarioDTO, Usuario>(objeto);
await _usuarioService.Add(map);
var retorno = List().Result.OrderByDescending(o => o.UsuarioId).FirstOrDefault();
return(retorno);
}
public IActionResult Add([FromBody] Usuario usuario)
{
usuario = _usuarioService.Add(usuario);
if (usuario == null)
{
return(NotFound());
}
return(Ok(usuario));
}
public async Task <IActionResult> PostUsuario([FromBody] UsuarioDto usuario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var Usuario = _usuarioService.Add(usuario);
return(Ok(Usuario));
}
public async Task <ActionResult <UsuarioViewModel> > Create(UsuarioViewModel UsuarioViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _dbUsuario.Add(_mapper.Map <Usuario>(UsuarioViewModel));
return(CustomResponse(UsuarioViewModel));
}
public async Task <IActionResult> Criar(UsuarioViewModel usuarioViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { Success = false, Message = "Modelo inválido." }));
}
await _usuarioService.Add(_mapper.Map <Usuario>(usuarioViewModel));
return(Ok());
}
public UsuarioModel Add(UsuarioModel usuarioModel)
{
var usuario = _mapper.Map <Usuario>(usuarioModel);
_uow.BeginTransaction();
usuario = _usuarioService.Add(usuario);
_uow.Commit();
return(_mapper.Map <UsuarioModel>(usuario));
}
public ActionResult Cadastrar(UsuarioViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
_usuarioSerivce.Add(_mapper.Map <UsuarioDTO>(viewModel));
TempData["Mensagem"] = "Cadastro realizado com sucesso. Efetue login.";
return(RedirectToAction("Login"));
}
public async Task <IActionResult> Post([FromBody] Usuario amigo)
{
try
{
await _usuarioService.Add(amigo);
return(Ok());
}
catch (Exception e)
{
return(BadRequest($"Não foi possivel inserir o novo registro.\nErro: {e.Message}"));
}
}
private async Task CadastrarNovoUsuarioCoMesmoLogin()
{
IUsuarioService service = serviceProvider.GetRequiredService <IUsuarioService>();
Usuario usuario = new Usuario();
usuario.Nome = $"Usuário de teste2";
usuario.Login = "******";
usuario.Password = DomainHelper.CalculateMD5Hash("teste2");
usuario.Setor = UsuarioSetor.Cozinha;
await service.Add(usuario);
service.Result.Any().Should().BeTrue();
}
public IActionResult Register([FromBody] UsuarioModel model)
{
var user = _service.ObterPorUsuario(model.Usuario);
if (user == null)
{
if (_service.Add(model))
{
return(Ok(model));
}
}
return(BadRequest("Esse nome de usuário já está sendo utilizado."));
}
public string CadastrarUsuario(UsuarioViewModel usuario)
{
try
{
if (ValidaDadosDeEntrada(usuario) != "")
{
return(JsonConvert.SerializeObject(new { code = 400, message = ValidaDadosDeEntrada(usuario) }));
}
else
{
if (usuario.AceitaReceberSms == true && string.IsNullOrEmpty(usuario.Celular))
{
return(JsonConvert.SerializeObject(new { code = 400, message = "Para receber SMS, é necessário que seja informado o número de celular do usuário." }));
}
if (!(VerificaSeJaNaoEstaCadastrado(usuario.Email)))
{
usuario.Ativo = true;
var usuarioService = Mapper.Map <UsuarioViewModel, Usuario>(usuario);
MD5 md5 = System.Security.Cryptography.MD5.Create();
byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(usuarioService.Senha);
byte[] hash = md5.ComputeHash(inputBytes);
StringBuilder sb = new StringBuilder();
for (int z = 0; z < hash.Length; z++)
{
sb.Append(hash[z].ToString("X2"));
}
var senhaCriptografada = sb.ToString();
usuarioService.Senha = senhaCriptografada;
_usuarioService.Add(usuarioService);
return(JsonConvert.SerializeObject(new { code = 200, message = "Usuário cadastrado com sucesso.", id = usuarioService.UsuarioId }));
}
else
{
return(JsonConvert.SerializeObject(new { code = 400, message = "O cadastro não pode ser realizado pois o email já está em uso." }));
}
}
}
catch
{
return(JsonConvert.SerializeObject(new { code = 400, message = "Erro no cadastro. Por favor, tente novamente." }));
}
}
public async Task <IActionResult> PostUsuario([FromBody] UsuarioCreaVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _usuarioService.Add(model);
var regreso = await _usuarioService.GetVM(user.usuario_id);
return(Ok(regreso));
}
private async Task TesteDeCrudIntegracao(IUsuarioService service)
{
Usuario usuarioNovo = null;
try
{
Usuario usuario = new Usuario();
usuario.Nome = $"Usuário de teste";
usuario.Login = "******";
usuario.Password = DomainHelper.CalculateMD5Hash("teste");
usuario.Setor = UsuarioSetor.Cozinha;
usuarioNovo = await service.Add(usuario);
service.Result.Any().Should().BeFalse();
usuarioNovo.Should().NotBeNull();
usuarioNovo.Id.Should().NotBe(0);
usuarioNovo.Nome.Should().Be(usuario.Nome);
usuarioNovo.Nome = $"{usuarioNovo.Nome} - Editado";
bool resultadoEdicao = await service.Edity(usuarioNovo);
resultadoEdicao.Should().BeTrue();
Usuario usuarioLogin = await service.GetByLoginPassword(usuario.Login, usuario.Password);
usuarioLogin.Should().NotBeNull();
IEnumerable <Usuario> entidades = await service.GetAll();
entidades.Any().Should().BeTrue();
Usuario usuarioById = await service.GetById(usuarioNovo.Id);
usuarioById.Should().NotBeNull();
usuarioById.Nome.Should().Be(usuario.Nome);
bool exists = service.Exists(usuarioNovo.Id);
exists.Should().BeTrue();
}
finally
{
if (usuarioNovo != null)
{
bool resultadoExclusao = await service.Delete(usuarioNovo.Id);
resultadoExclusao.Should().BeTrue();
}
}
}
public async Task <IActionResult> Post([FromBody] PersonalDTO model)
{
var user = new Usuario(model.Id, model.Email, model.NombrePersonal, model.ApellidoPersonal, model.Cargo,
model.FechaAfilacion, model.Email, model.PhoneNumber, model.Password, model.Pais);
user.EmailConfirmed = true;
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(Ok(_usuarioService.Add(model)));
}
return(Ok());
}
public ActionResult <Usuario> Post([FromBody] UsuarioVo usuarioVo)
{
try
{
var ret = _usuarioService.Add(_usuarioConverter.Parse(usuarioVo));
return(Ok(ret));
}
catch (ArgumentNullException e)
{
return(NotFound(e.Message));
}
catch (Exception e)
{
return(BadRequest(e.Message + " | " + e.InnerException.Message));
}
}
public Usuario AddUsuarioDistribuidora(IdentityUser usuarioIdentity, DistribuidoraVM distribuidora, string empresa_Global)
{
try
{
Usuario usuario = new Usuario(distribuidora.Nome, true, distribuidora.Cpf.ToString(), usuarioIdentity.Id, EnumPerfil.Distribuidora);
var usuariocriado = _usuarioService.Add(usuario);
EmpresaUsuario empresaUsuario = new EmpresaUsuario(usuariocriado.Id_Usuario, Convert.ToInt32(empresa_Global));
_empresaUsuarioService.Add(empresaUsuario);
return(usuariocriado);
}
catch (System.Exception)
{
throw;
}
}
public Usuario AddUsuarioTecnico(IdentityUser usuarioIdentity, TecnicoVM tecnico, int id_Endereco, string empresa_Global)
{
try
{
Usuario usuario = new Usuario(tecnico.Nome, true, tecnico.Cpf.ToString(), usuarioIdentity.Id, EnumPerfil.Tecnico);
usuario.Id_Endereco = id_Endereco;
var usuariocriado = _usuarioService.Add(usuario);
EmpresaUsuario empresaUsuario = new EmpresaUsuario(usuariocriado.Id_Usuario, Convert.ToInt32(empresa_Global));
_empresaUsuarioService.Add(empresaUsuario);
return(usuariocriado);
}
catch (System.Exception)
{
throw;
}
}
