public async Task <UsuarioResponse> UpdateUser(ModificarUsuarioRequest request)
{
UsuarioResponse response = new UsuarioResponse();
var paramUserId = new SqlParameter("@UserId", request.UserId);
var paramNombreUser = new SqlParameter("@nombre_user", request.nombre_user);
var paramTelUser = new SqlParameter("@telefono_user", request.telefono_user);
var paramFnacUser = new SqlParameter("@fnac_user", request.fnac_user);
var paramPatron = new SqlParameter("@Patron", config["AppSettings:PatronConfig"]);
try
{
IList <TblUsuarios> usr = await db.Usuarios.FromSqlRaw(
"SP_ModificarUsuario @UserId,@nombre_user,@telefono_user,@fnac_user,@Patron ",
paramUserId, paramNombreUser, paramTelUser, paramFnacUser, paramPatron).ToListAsync();
if (usr != null && usr.Count == 1)
{
response = map.Map <UsuarioResponse>(usr.FirstOrDefault());
}
return(response);
}
catch (Exception ex)
{
Console.WriteLine($"{ex.Message} {ex.InnerException?.Message}");
throw;
}
}
public async Task <UsuarioResponse> AddUser(RegistroUsuarioRequest request)
{
UsuarioResponse response = new UsuarioResponse();
var paramNombreUser = new SqlParameter("@nombre_user", request.nombre_user);
var paramUserName = new SqlParameter("@username", request.username);
var paramEmailUser = new SqlParameter("@email_user", request.email_user);
var paramPassUser = new SqlParameter("@pass_user", request.pass_user);
var paramTelUser = new SqlParameter("@telefono_user", request.telefono_user);
var paramFnacUser = new SqlParameter("@fnac_user", request.fnac_user);
var paramPatron = new SqlParameter("@Patron", config["AppSettings:PatronConfig"]);
try
{
IList <TblUsuarios> usr = await db.Usuarios.FromSqlRaw(
"SP_AgregarUsuario @nombre_user, @username, @email_user,@pass_user,@telefono_user,@fnac_user,@Patron ",
paramNombreUser, paramUserName, paramEmailUser, paramPassUser, paramTelUser, paramFnacUser, paramPatron).ToListAsync();
if (usr != null && usr.Count == 1)
{
response = map.Map <UsuarioResponse>(usr.FirstOrDefault());
}
return(response);
}
catch (Exception ex)
{
Console.WriteLine($"{ex.Message} {ex.InnerException?.Message}");
throw;
}
}
public UsuarioResponse RegistrarUsuario(UsuarioRequest request)
{
UsuarioResponse response = null;
Usuario usuario = new Usuario();
usuario.NombreCompleto = request.nombreCompleto;
usuario.Edad = request.edad;
usuario.Correo = request.correo;
var password = AES.GetInstance().Encrypt(request.clave);
usuario.Clave = password;
var exists = _context.Usuarios.Any(x => x.Correo == usuario.Correo);
if (!exists)
{
_context.Usuarios.Add(usuario);
int result = _context.SaveChanges();
response = new UsuarioResponse()
{
correo = usuario.Correo,
nombreCompleto = usuario.NombreCompleto
};
response = result == 1 ? response : null;
}
return(response);
}
public UsuarioResponse cambiarPerfil(UsuarioRequest request)
{
DataAccess.DataAccess da = new DataAccess.DataAccess {
CadenaConexion = ConfigurationManager.ConnectionStrings["jadetBD"].ConnectionString
};
var resultado = da.guardarUsuario(new DataAccess.Usuario {
Direccion = request.Direccion,
Foto = request.Foto,
Id = request.Id,
IdEstatus = request.IdEstatus,
IdRol = request.IdRol,
Nombre = request.Nombre,
Telefono = request.Telefono,
UserName = request.Usuario,
Password = request.Password,
ZonaPaqueteria = request.ZonaPaqueteria
});
UsuarioResponse response = new UsuarioResponse {
Usuario = resultado.UserName,
ErrorMensaje = resultado.ErrorMensaje,
ErrorNumero = resultado.ErrorNumero,
Id = resultado.Id,
Nombre = resultado.Nombre,
Direccion = resultado.Direccion,
Password = resultado.Password,
Foto = resultado.Foto,
IdEstatus = resultado.IdEstatus,
IdRol = resultado.IdRol,
Telefono = resultado.Telefono,
ZonaPaqueteria = resultado.ZonaPaqueteria
};
return(response);
}
public override Task <UsuarioResponse> Excluir(RegistroUsuario registroUsuario, ServerCallContext context)
{
return(Task.Run(() =>
{
var usuario = new Usuario(registroUsuario);
var response = new UsuarioResponse();
response.Error = 0;
try
{
// AtualizarServidor();
Usuario.Excluir(usuario);
}
catch (Exception e)
{
response.Message = e.Message;
response.Error = 1;
return response;
}
response.Message = "Excluido com sucesso!";
return response;
}));
}
public TweetResponse()
{
Usuario = new UsuarioResponse();
Tags2 = new List <TagResponse>();
Pais = new PaisResponse();
Idioma = new IdiomaResponse();
}
public HttpResponse <List <UsuarioResponse> > Todos()
{
using (var db = new GeviApiContext())
{
var usuarios = db.Usuarios.ToList();
var response = new List <UsuarioResponse>();
foreach (var u in usuarios)
{
var nuevo = new UsuarioResponse()
{
Id = u.Id,
Email = u.Email,
EsEmpleado = u is Empleado,
FechaRegistro = u.FechaRegistro,
Nombre = u.Nombre
};
response.Add(nuevo);
}
return(newHttpListResponse(response));
}
}
public ActionResult <UsuarioResponse> Put(int id, [FromBody] UsuarioRequest.UsuarioUpdate updateUsuario)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IResponse <UsuarioEntity> respuesta = new UsuarioResponse();
try
{
UsuarioEntity usuario = _usuarioService.Update(id, updateUsuario);
respuesta.Resultado = "S";
respuesta.Datos.Add(usuario);
}
catch (Exception ex)
{
respuesta.Resultado = "E";
respuesta.Mensaje = ex.Message.ToString();
}
return(Ok(respuesta));
}
public bool Delete(ref string error, int id)
{
UsuarioResponse response = null;
try
{
var obj = new Usuario()
{
Id = id
};
var objReq = new UsuarioRequest
{
Item = obj,
Operacion = Operacion.Eliminar
};
using (var proxy = new ServicioClient())
{
response = proxy.UsuarioEjecutarOperacion(objReq);
}
error = !response.Resultado ? response.MensajeError : "";
}
catch (Exception ex)
{
error = ex.Message;
}
return(response != null && response.Resultado);
}
public UsuarioResponse RetornaUsuario(int codigoUsuario)
{
try
{
var result = usuarioRepositorio.RetornaUsuario(codigoUsuario);
UsuarioResponse response = new UsuarioResponse()
{
CodigoUsuario = result.IdUsuario,
Nome = result.NomeUsuario,
DataUltimoLogin = result.Dataultimologin,
Email = result.Email,
Perfil = result.Perfil.NomePerfil,
Identificacao = result.Perfil.IdtPerfil,
CodigoPerfil = result.Perfil.IdPerfil
};
return(response);
}
catch
{
unitOfWork.Rollback();
throw;
}
finally
{
unitOfWork.Dispose();
}
}
public UsuarioResponse Login(Usuarios usuario)
{
UsuarioResponse uRes = new UsuarioResponse();
try
{
using (ServiciosContext context = new ServiciosContext())
{
var user = context.Usuarios.Where(u => u.Usuario == usuario.Usuario && u.Clave == usuario.Clave).FirstOrDefault();
if (user == null)
{
uRes.Mensaje = "Nombre de usuario y / o contraseña incorrectos";
}
else
{
user.Logueado = true;
context.SaveChanges();
Mapper(uRes, user);
LoggerData.InsertLogger(user.Id, "Login");
}
}
}
catch (Exception ex)
{
uRes.Mensaje = ex.Message;
}
return(uRes);
}
public UsuarioResponse Registro(Usuarios usuario)
{
UsuarioResponse uRes = new UsuarioResponse();
try
{
using (ServiciosContext context = new ServiciosContext())
{
var user = context.Usuarios.Where(u => u.Usuario == usuario.Usuario)
.Select(x => new Usuarios
{
Usuario = x.Usuario
}).FirstOrDefault();
if (user != null)
{
uRes.Mensaje = "El nombre de usuario ya se encuentra en uso";
}
else
{
context.Usuarios.Add(usuario);
context.SaveChanges();
Mapper(uRes, usuario, false, "Usuario registrado correctamente");
}
}
}
catch (Exception ex)
{
uRes.Mensaje = ex.Message;
}
return(uRes);
}
public ActionResult <UsuarioResponse> Get(int id)
{
IResponse <UsuarioEntity> respuesta = new UsuarioResponse();
try
{
UsuarioEntity usuario = _usuarioService.FindById(id);
if (usuario != null)
{
respuesta.Resultado = "S";
respuesta.Datos.Add(usuario);
}
else
{
respuesta.Resultado = "N";
respuesta.Mensaje = "Usuario no encontrado";
}
}
catch (Exception ex)
{
respuesta.Resultado = "E";
respuesta.Mensaje = ex.Message.ToString();
}
return(Ok(respuesta));
}
public UsuarioResponse GetAdmin(int id)
{
UsuarioResponse response = new UsuarioResponse();
var resultDb = context.Usuario.Where(x => x.IsAdmin).FirstOrDefault(u => u.Id == id);
response = _mapper.Map <Usuario, UsuarioResponse>(resultDb);
return(response);
}
private void Mapper(UsuarioResponse uRes, Usuarios usuario)
{
uRes.Id = usuario.Id;
uRes.Nombre = usuario.Nombre;
uRes.Apellido = usuario.Apellido;
uRes.Usuario = usuario.Usuario;
uRes.Logueado = usuario.Logueado;
}
public IActionResult autenticar([FromBody] UsuarioRequest userRequest)
{
string cnn = _config.GetConnectionString("cnn");
UsuarioResponse respuesta = logBL.Autenticar(userRequest, cnn);
//List<ProductoBE> respuesta = logBL.goo(userRequest, cnn);
return(Ok(respuesta));
}
public Response Login([FromBody] UsuarioDto usuario)
{
Response responseLogin = new Response();
try {
UsuarioResponse user = new UsuarioResponse();
var resultDb = context.Usuario.FirstOrDefault(u => u.Mail == usuario.Mail);
user = _mapper.Map <Usuario, UsuarioResponse>(resultDb);
if (user != null && user.Contraseña.Equals(usuario.Password))
{
// Leemos el secret_key desde nuestro appseting
var secretKey = _configuration.GetValue <string>("SecretKey");
var key = Encoding.ASCII.GetBytes(secretKey);
// Creamos los claims (pertenencias, características) del usuario
/* var claims = new[]
* {
*
* new System.Security.Claims.ClaimsIdentity("UserData", JsonConvert.SerializeObject(user))
* };*/
ClaimsIdentity claims = new ClaimsIdentity();
Claim datos = new Claim("UserData", JsonConvert.SerializeObject(user));
claims.AddClaim(datos);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = claims,
// Nuestro token va a durar un día
Expires = DateTime.UtcNow.AddDays(1),
// Credenciales para generar el token usando nuestro secretykey y el algoritmo hash 256
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var tokenHandler = new System.IdentityModel.Tokens.Jwt.JwtSecurityTokenHandler();
var createdToken = tokenHandler.CreateToken(tokenDescriptor);
responseLogin.cod = 200;
responseLogin.data = tokenHandler.WriteToken(createdToken);
responseLogin.mensaje = "OK";
}
else
{
responseLogin.cod = 401;
responseLogin.data = null;
responseLogin.mensaje = "Credenciales invalidas";
}
}catch (Exception e)
{
responseLogin.cod = 502;
responseLogin.data = null;
responseLogin.mensaje = "Error al intentar verificar el usuario";
}
return(responseLogin);
}
private void Mapper(UsuarioResponse uRes, Usuarios usuario, bool logueado, string mensaje)
{
uRes.Id = usuario.Id;
uRes.Nombre = usuario.Nombre;
uRes.Apellido = usuario.Apellido;
uRes.Usuario = usuario.Usuario;
uRes.Logueado = logueado;
uRes.Mensaje = mensaje;
}
public ResponseEnvelope Response(UsuarioResponse usuarioResponse)
{
var responseEnvelope = new ResponseEnvelope()
{
HttpStatusCode = (HttpStatusCode)usuarioResponse.HttpStatusCode
};
return(responseEnvelope);
}
private HttpResponse <UsuarioResponse> newHttpResponse(UsuarioResponse response)
{
return(new HttpResponse <UsuarioResponse>()
{
StatusCode = HttpStatusCode.OK,
ApiResponse = new ApiResponse <UsuarioResponse>()
{
Data = response,
Error = null
}
});
}
public UsuarioResponse ValidaUsuario(UsuarioRequest Request)
{
UsuarioResponse Response = new UsuarioResponse();
Usuario Entidad = new Usuario();
AttendanceController Controller = new AttendanceController();
Entidad = Controller.ValidaUsuario(Request.NombreUsuario, Request.Password);
Response.usuario = Entidad;
if (Response.usuario.idUsuario > 0)
{
Response.UsuarioValido = true;
}
return(Response);
}
public HttpResponse <UsuarioResponse> CambiarContrasenia(UsuarioRequest request)
{
if (request == null)
{
return(newHttpErrorResponse(new Error("El usuario que se intenta modificar es invalido.")));
}
using (var db = new GeviApiContext())
{
var usuario = db.Usuarios
.Where(u => u.Id == request.UsuarioId)
.FirstOrDefault();
if (usuario == null)
{
return(newHttpErrorResponse(new Error("No existe el usuario")));
}
var encryptionManager = new EncryptionManager();
var nuevaContraseniaEncriptada = encryptionManager.Encryptdata(request.Contrasenia);
var viejaContraseniaEncriptada = encryptionManager.Encryptdata(request.ContraseniaVieja);
if (!usuario.Contrasenia.Equals(viejaContraseniaEncriptada))
{
return(newHttpErrorResponse(new Error("La contraseña actual no es correcta")));
}
if (nuevaContraseniaEncriptada == viejaContraseniaEncriptada)
{
return(newHttpErrorResponse(new Error("La nueva contraseña no puede ser igual a la anterior")));
}
usuario.Contrasenia = nuevaContraseniaEncriptada;
db.Entry(usuario).State = EntityState.Modified;
db.SaveChanges();
var response = new UsuarioResponse()
{
Id = usuario.Id,
Nombre = usuario.Nombre,
Email = usuario.Email,
EsEmpleado = usuario is Empleado,
FechaRegistro = usuario.FechaRegistro
};
return(newHttpResponse(response));
}
}
public async Task <IActionResult> Obter(Guid idUsuario)
{
try
{
string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value;
AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims);
UsuarioResponse response = _serviceUsuario.Obter(idUsuario);
return(await ResponseAsync(response, _serviceUsuario));
}
catch (Exception ex)
{
return(await ResponseExceptionAsync(ex));
}
}
public UsuarioResponse Gravar(Usuario item)
{
var retorno = _db.Database.SqlQuery <UsuarioResponse>("GravaUsuario @Nome,@Email,@Senha,@TipoUsuario"
, new SqlParameter("Nome", item.Nome)
, new SqlParameter("Email", item.Email)
, new SqlParameter("Senha", item.Senha.ConvertToMD5())
, new SqlParameter("TipoUsuario", item.TipoUsuario.ToString())
).FirstOrDefault();
if (retorno == null)
{
retorno = new UsuarioResponse();
}
return(retorno);
}
public HttpResponseMessage Get([FromUri] int id)
{
try
{
UsuarioResponse usuarioResponse = _userBusiness.FindById(id);
return(ResponseBasicJson(HttpStatusCode.OK, usuarioResponse));
}
catch (ValidacaoException e)
{
return(ResponseBasicJson(e.MensagemError.StatusCode, e.MensagemError));
}
catch (Exception e)
{
MensagemError msg = MensagensUtil.ObterMensagem(HttpStatusCode.BadRequest, "M199");
return(ResponseBasicJson(msg.StatusCode, msg));
}
}
public UsuarioResponse autenticar(UsuarioRequest userRequest, string cnn)
{
List <ProductoBE> lista = new List <ProductoBE>();
UsuarioResponse u = null;
try
{
using (SqlConnection objConection = new SqlConnection(cnn))
{
using (SqlCommand objCommand = new SqlCommand("PA_GET_USER_AUTHENTICATION", objConection))
{
objCommand.CommandType = CommandType.StoredProcedure;
objCommand.Parameters.Add(new SqlParameter("@pi_user", SqlDbType.VarChar)
{
Value = userRequest.User
});
objCommand.Parameters.Add(new SqlParameter("@pi_pass", SqlDbType.VarChar)
{
Value = userRequest.Pass
});
objCommand.Connection.Open();
using (IDataReader dr = objCommand.ExecuteReader())
{
while (dr.Read())
{
//UsuarioResponse u = new UsuarioResponse();
u = new UsuarioResponse();
u.IdUsuario = dr.GetInt32(dr.GetOrdinal("IdUsuario"));
u.FirstName = dr.GetString(dr.GetOrdinal("FirstName"));
u.LastName = dr.GetString(dr.GetOrdinal("LastName"));
u.UserName = dr.GetString(dr.GetOrdinal("UserName"));
u.Email = dr.GetString(dr.GetOrdinal("Email"));
u.Productos = new List <ProductoBE>();
u.Productos.AddRange(AddProductInUser(userRequest, cnn));
//lista.Add(u);
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return(u);
}
public ActionResult <UsuarioResponse> Delete(int id)
{
IResponse <UsuarioEntity> respuesta = new UsuarioResponse();
try
{
bool resDelete = _usuarioService.Delete(id);
respuesta.Resultado = resDelete == true ? "S" : "N";
}
catch (Exception ex)
{
respuesta.Resultado = "E";
respuesta.Mensaje = ex.Message.ToString();
}
return(Ok(respuesta));
}
public UsuarioResponse Autenticacion(AutenticacionRequest Model)
{
UsuarioResponse usuarioResponse = new UsuarioResponse();
string Spassword = Utiles.GetSHA256(Model.Password);
var Usuario = _db.Usuario.Where(u => u.Email == Model.Email && u.Contrasena == Spassword).FirstOrDefault();
if (Usuario == null)
{
return(null);
}
usuarioResponse.Email = Usuario.Email;
usuarioResponse.Token = GetToken(Usuario);
return(usuarioResponse);
}
public UsuarioResponse Response(AuthRequest auth)
{
UsuarioResponse usuarioResponse = new UsuarioResponse();
using (var db = new italika_dbContext())
{
string sPass = Encrypt.GetSha256(auth.contraseña);
var usuario = db.Usuarios.Where(db => db.NombreUsuario == auth.nombre_usuario && db.Contraseña == auth.contraseña).FirstOrDefault();
if (usuario == null)
{
return(null);
}
usuarioResponse.Nombre_Usuario = usuario.NombreUsuario;
usuarioResponse.Token = GetToken(usuario);
}
return(usuarioResponse);
}
public ActionResult <UsuarioResponse> Get()
{
IResponse <UsuarioEntity> respuesta = new UsuarioResponse();
try
{
List <UsuarioEntity> usuarios = _usuarioService.Find() ?? new List <UsuarioEntity>();
respuesta.Resultado = "S";
respuesta.Datos = usuarios;
}
catch (Exception ex)
{
respuesta.Resultado = "E";
respuesta.Mensaje = ex.Message.ToString();
}
return(Ok(respuesta));
}
