public IActionResult Put(int id, [FromBody] UsuarioInput input)
{
CheckStatus checkStatus = null;
Usuario usuario = new Usuario();
if (ModelState.IsValid)
{
try
{
usuario = _repository.Single <Usuario>(p => p.Id == id);
usuario.Nombres = input.nombres;
usuario.Apellidos = input.apellidos;
usuario.Email = input.email;
usuario.Password = input.contrasena;
usuario.ImagenUrl = input.imagenurl;
usuario.Estado = input.estado;
checkStatus = new CheckStatus(Status.Ok, string.Format(Mensaje.Guardar, Mensaje.Usuario));
return(StatusCode(200, checkStatus));
}
catch (Exception ex)
{
checkStatus = new CheckStatus(Status.Error, ex.Message);
return(StatusCode(422, checkStatus));
}
}
else
{
checkStatus = new CheckStatus(Status.Error, Mensaje.InputInvalido);
return(StatusCode(422, checkStatus));
}
}
public CheckStatus Create(BaseInputEntity entity)
{
CheckStatus checkstatus = null;
UsuarioInput input = (UsuarioInput)entity;
Usuario usuario = new Usuario();
usuario.Nombres = input.nombres;
usuario.Apellidos = input.apellidos;
usuario.Email = input.email;
usuario.Password = input.contrasena;
usuario.ImagenUrl = input.imagenurl;
usuario.Estado = input.estado;
try
{
_repository.Create <Usuario>(usuario);
SaveChanges();
checkstatus = new CheckStatus(usuario.Id, usuario.Nombres, Status.Ok,
string.Format(Mensaje.Guardar, Mensaje.Usuario));
}
catch (Exception ex)
{
checkstatus = new CheckStatus(Status.Error, ex.Message);
}
return(checkstatus);
}
public async Task <IActionResult> PutUsuario(UsuarioInput input, int id)
{
try
{
var usuarioDb = _usuarioRepository.GetById(id);
if (usuarioDb == null)
{
return(StatusCode((int)HttpStatusCode.NotFound, "Este usuário não existe para ser alterado."));
}
// Caso o usuário seja o que foi criado por padrão na inicialização da API
if (usuarioDb.Email == "*****@*****.**")
{
return(StatusCode((int)HttpStatusCode.Forbidden, "Você não pode alterar o usuário admin padrão."));
}
usuarioDb.AlterarDados(input.Nome, input.Email, input.Senha);
_usuarioRepository.UpdateUsuario(usuarioDb);
// Salva na DB
await _usuarioRepository.UnitOfWork.SaveDbChanges();
return(StatusCode(200, $"Usuário id [{usuarioDb.Id}] editado com sucesso."));
}
catch (Exception ex)
{
return(StatusCode(500, "Ocorreu algum erro na alteração do usuário específicado."));
}
}
public async Task <IActionResult> Post([FromBody] UsuarioInput input)
{
try
{
var result = await _mediator.Send(
new NewUsuarioCommand(
input.Nome,
input.Login,
input.Senha,
input.ConfirmarSenha,
input.Enderecos,
input.DDD,
input.Telefone)
);
if (result.Ok)
{
return(Ok());
}
return(BadRequest(result.Errors));
}
catch (Exception ex)
{
//logar erro em algum lugar
return(StatusCode(500, ex.Message));
}
}
public async Task <IActionResult> CreateUsuario(UsuarioInput input)
{
try
{
var usuarioDb = _usuarioRepository.GetByEmail(input.Email);
// Validação para verificar se já existe usuário com email igual já cadastrado
if (usuarioDb != null)
{
return(StatusCode(403, $"Já existe um usuário com o email {input.Email}."));
}
Usuario newUsuario = new Usuario(input.Nome, input.Email, input.Senha);
_usuarioRepository.Create(newUsuario);
// Salva as alterações no banco
await _usuarioRepository.UnitOfWork.SaveDbChanges();
return(StatusCode(200, $"Usuario {input.Email} criado."));
}
catch (Exception ex)
{
return(StatusCode(500, "Ocorreu algum erro na criação do usuário"));
}
}
public IActionResult Post([FromBody] UsuarioInput input)
{
try
{
CheckStatus checkStatus = null;
if (ModelState.IsValid)
{
checkStatus = _manager.Create(input);
if (checkStatus.apiEstado.Equals(Status.Error))
{
return(StatusCode(422, checkStatus));
}
return(StatusCode(201, checkStatus));
}
else
{
checkStatus = new CheckStatus(Status.Error, Mensaje.InputInvalido);
return(StatusCode(422, checkStatus));
}
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.SERVICE_ERROR, ex, ex.Message);
return(new EmptyResult());
}
}
public bool TryAddUsuario(UsuarioInput usuario, out int id)
{
try
{
using (var conn = CriarConexao())
using (var tran = conn.BeginTransaction())
using (var cmd = conn.CreateCommand())
{
cmd.CommandText =
"insert into usuarios (nome) values (@nome)";
cmd.Parameters.Add(new MySqlParameter("@nome", usuario.Nome));
cmd.ExecuteNonQuery();
cmd.CommandText = "SELECT LAST_INSERT_ID()";
using (var dr = cmd.ExecuteReader())
{
dr.Read();
id = Convert.ToInt32(dr[0]);
}
tran.Commit();
return(true);
}
}
catch (Exception ex)
{
_logger.LogWarning(ex, "TryAddUsuario({usuario})");
id = 0;
return(false);
}
}
public async Task <IActionResult> Post([FromBody] UsuarioInput input)
{
var usuario = await _usuarioAppService
.InserirUsuarioAsync(input)
.ConfigureAwait(false);
return(CreatedContent("", usuario));
}
public IActionResult Post([FromBody] UsuarioInput input)
{
CheckStatus checkStatus = new CheckStatus();
checkStatus = usuarioRepository.Login(input);
return(Ok(checkStatus));
}
public async Task <UsuarioViewModel> InserirUsuarioAsync(UsuarioInput input)
{
var perfil = await _perfilRepositorio
.RecuperarIdAsync(input._PerfilID)
.ConfigureAwait(false);
if (perfil is null)
{
_notification.NewNotificationBadRequest("O Perfil não existe!");
return(default);
public void Salve(UsuarioInput usuario)
{
var usu = UsuarioInputTOUsuario(usuario);
bool verdade = ValidacaoUser(usu);
if (verdade)
{
this.repositoryUsuario.Salve(usu);
}
}
public BasePlayground(ApiConfiguration configuration)
{
ApiConfiguration = configuration;
httpClient = new HttpClient();
usuarioInput = new UsuarioInput
{
UsuarioId = Environment.GetEnvironmentVariable("CASADOCODIGO_USERID", EnvironmentVariableTarget.User),
Password = Environment.GetEnvironmentVariable("CASADOCODIGO_PASSWORD", EnvironmentVariableTarget.User),
};
}
public ActionResult <UsuarioPostOutput> Post([FromBody] UsuarioInput usuario)
{
if (_repositorio.TryAddUsuario(usuario, out var id))
{
return(new UsuarioPostOutput(id));
}
else
{
return(new UsuarioPostOutput(sucesso: false, erro: "Nome já utilizado"));
}
}
private Usuario UsuarioInputTOUsuario(UsuarioInput usuarioInput)
{
return(new Usuario(
id: usuarioInput.id,
nome: usuarioInput.Nome,
email: usuarioInput.Email,
senha: usuarioInput.Senha,
ativo: usuarioInput.Ativado,
role: usuarioInput.Roles
));
}
public IActionResult Put([FromBody] UsuarioInput user)
{
if (string.IsNullOrEmpty(user.Email) || string.IsNullOrEmpty(user.Nome) || string.IsNullOrEmpty(user.Senha))
{
return(BadRequest());
}
else
{
this.usuarioService.Alterar(user);
return(Ok());
}
}
public async Task <IActionResult> Post([FromBody] UsuarioInput usuarioInput)
{
try {
var usuario = await _usuarioAppService.InsertAsync(usuarioInput).ConfigureAwait(false);
return(Created("", usuario));
}
catch (ArgumentException arg)
{
return(BadRequest(arg.Message));
}
}
public async Task <IActionResult> Put([FromRoute] int id, [FromBody] UsuarioInput usuarioInput)
{
try
{
var usuario = await _usuarioAppService.UpdateUsuario(usuarioInput, id).ConfigureAwait(false);
return(Ok(usuario));
}
catch (ArgumentException arg)
{
return(BadRequest(arg.Message));
}
}
public async Task <IActionResult> ExemploHashSenha(UsuarioInput input)
{
try
{
var tipoUsuario = tipoUsuarioRepository.GetById(input.TipoUsuarioId);
if (tipoUsuario == null)
{
return(StatusCode(404, new List <string>()
{
$"TipoUsuario id [{input.TipoUsuarioId}] não encontrado no banco de dados"
}));
}
//Gera Hash da senha digitada
var senhaHash = new PasswordHasher <UsuarioInput>().HashPassword(input, input.Senha);
Usuario usuario = null;
try
{
usuario = new Usuario(input.Nome, input.Email, senhaHash, input.TipoUsuarioId);
}
catch (Exception ex)
{
return(StatusCode(400, new List <string>()
{
"Ocorreu um erro na criação do usuário",
ex.Message
}));
}
usuarioRepository.Create(usuario);
await usuarioRepository.UnitOfWork.SaveDbChanges();
//Apenas para verificar se a senha esta como HashCode
return(StatusCode(200, usuario));
}
catch (Exception ex)
{
return(BadRequest(new List <string>()
{
"Ocorreu um erro desconhecido na requisição de criar o usuário, tente novamente mais tarde.",
ex.Message
}));
}
}
public CheckStatus Login(UsuarioInput input)
{
CheckStatus checkStatus = new CheckStatus();
Usuario usuario = new Usuario();
usuario.IdUsuario = 0;
usuario.Nombre = input.nombre;
usuario.Correo = input.correo;
usuario.Tipo = input.tipo;
usuario.IdSocial = input.socialId;
usuario.IdFirebase = input.firebase;
checkStatus = mensajeRepository.Login(usuario);
return(checkStatus);
}
private bool Conectar()
{
List <string> lista = PreencheLista();
Token token = new Token();
UsuarioInput usuario = new UsuarioInput {
usuario = user.Text, senha = password.Text, topicos = lista
};
App.Argumentos.modo = "c";
App.Argumentos.ip = serverIp.Text;
App.Argumentos.porta = 10553;
App.Argumentos.debug = true;
App.Argumentos.dh = 1024;
App.Argumentos.aes = 128;
App.Argumentos.usuarioInput = usuario;
App.Argumentos.token = token;
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
IPAddress ip = IPAddress.Parse(serverIp.Text);
var json = string.Empty;
json = JsonConvert.SerializeObject(usuario);
Console.Write(json);
byte[] sendBuf = Encoding.UTF8.GetBytes(json);
IPEndPoint ep = new IPEndPoint(ip, 10553);
s.SendTo(sendBuf, ep);
Console.WriteLine("Enviou");
IPEndPoint recEp = new IPEndPoint(IPAddress.Any, 0);
EndPoint Remote = recEp;
byte[] recBuf = new byte[1024];
int receivedDataLength = s.ReceiveFrom(recBuf, ref Remote);
Console.WriteLine(" Recebeu " + Encoding.UTF8.GetString(recBuf, 0, receivedDataLength));
App.Argumentos.token.token = Encoding.UTF8.GetString(recBuf, 0, receivedDataLength);
s.Close();
return(true);
}
public bool TryAddUsuario(UsuarioInput usuario, out int id)
{
if (_usuarios.Any(u => u.Nome == usuario.Nome))
{
id = 0;
return(false);
}
id = _usuarios.Any() ? _usuarios.Max(u => u.Id) + 1 : 1;
_usuarios.Add(new Usuario()
{
Nome = usuario.Nome,
Id = id
});
return(true);
}
public Response <bool> InsertUsuario(UsuarioInput usuario)
{
Response <bool> response = new Response <bool>();
try
{
var user = new Usuario()
{
// Id = Convert.ToInt32(usuario.id),
IdRol = Convert.ToInt32(usuario.idRol),
Nombre = usuario.nombre,
Password = usuario.password,
Status = Convert.ToBoolean(usuario.status)
};
var result = usuarioManager.Insert(user);
if (result)
{
response.Data = result;
response.Status = true;
}
else
{
response.Data = result;
response.Status = false;
response.Error = "Error al ingresar el usuario, Verifique si el nombre del usuario ya existe o comuniquese con el administrador";
}
}
catch (Exception ex)
{
response.Data = false;
response.Status = false;
response.Error = ex.ToString();
Logger.Logguer(System.Reflection.MethodBase.GetCurrentMethod().Name, "Exception ", ex.Message);
}
return(response);
}
public CheckStatus Update(BaseInputEntity entity)
{
CheckStatus checkstatus = null;
UsuarioInput input = (UsuarioInput)entity;
Usuario usuario = _repository.Single <Usuario>(p => p.Id == input.id);
if (usuario != null)
{
usuario.Nombres = input.nombres;
usuario.Apellidos = input.apellidos;
usuario.Email = input.email;
usuario.ImagenUrl = input.imagenurl;
usuario.Estado = input.estado;
usuario.Eliminado = false;
try
{
_repository.Update <Usuario>(usuario);
SaveChanges();
checkstatus = new CheckStatus(Status.Ok, string.Format(Mensaje.Guardar, Mensaje.Usuario));
}
catch (Exception ex)
{
checkstatus = new CheckStatus(Status.Error, ex.Message);
}
}
else
{
checkstatus = new CheckStatus(Status.Error, String.Format(Mensaje.NoExiste, Mensaje.Usuario));
}
return(checkstatus);
}
public async Task <ActionResult <string> > Post(
[FromBody] UsuarioInput input,
[FromServices] UsersDAO usersDAO)
{
if (input == null || String.IsNullOrWhiteSpace(input.UsuarioId))
{
return(BadRequest("Login inválido"));
}
var user = await _userMgr.FindByIdAsync(input.UsuarioId);
if (user == null)
{
return(BadRequest("Login inválido"));
}
if (_hasher.VerifyHashedPassword(user, user.PasswordHash, input.Password) == PasswordVerificationResult.Failed)
{
return(BadRequest("Login inválido"));
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, input.UsuarioId)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Tokens:Key"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(_config["Tokens:Issuer"],
_config["Tokens:Issuer"],
claims,
expires: DateTime.Now.AddSeconds(int.Parse(_config["Tokens:ExpiresSecs"])),
signingCredentials: creds);
return(Ok(new JwtSecurityTokenHandler().WriteToken(token)));
}
public Usuario Insert(UsuarioInput input)
{
var usuario = new Usuario(input.Nome,
input.Cpf,
input.Login,
input.Senha,
input.TipoPerfil,
input.Cache,
input.GeneroObra,
input.DataDisponibilidade,
input.Cidade,
input.Estado,
input.Cep);
if (!usuario.IsValid())
{
_notification.NewNotificationBadRequest("Dados Obrigatórios Não foram preenchidos!");
}
var id = _usuarioRepository.Insert(usuario);
usuario.SetId(id);
return(usuario);
}
public UsuarioOutput Autenticar(UsuarioInput input)
{
var usuario = UsuariosMock.Usuarios.FirstOrDefault(u => u.Id == input.idUsuario);
var usuarioOutput = new UsuarioOutput();
if (usuario == null)
{
usuarioOutput.StatusAutenticacao = StatusAutenticacao.UsuarioNaoEncontrado;
usuarioOutput.Mensagem = $"Usuário não encontrado com o ID {input.idUsuario}";
}
else if (usuario.Senha != input.Senha)
{
usuarioOutput.StatusAutenticacao = StatusAutenticacao.SenhaInvalida;
usuarioOutput.Mensagem = $"Usuário ou senha inválidos";
}
else
{
usuarioOutput.StatusAutenticacao = StatusAutenticacao.Autenticado;
usuarioOutput.Mensagem = $"Senha válida";
}
return(usuarioOutput);
}
public IActionResult Post([FromBody] UsuarioInput input)
{
var item = _usuarioAppService.Insert(input);
return(CreatedContent("", item));
}
public UsuarioOutput Post(UsuarioInput input)
{
return(_usuariosBll.Autenticar(input));
}
