public ResponseModel ValidarLogin(string Usuario, string Contraseña)
{
var rm = new ResponseModel();
Contraseña = HashHelper.SHA1(Contraseña);
try
{
using (var db = new ModeloGGYM())
{
//Contraseña = HashHelper.SHA1(Contraseña);
var usuario = db.USUARIO.Where(x => x.EMAIL == Usuario)
.Where(x => x.PASSWORD == Contraseña)
.SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.ID_USUARIO.ToString());
rm.SetResponse(true);
rm.idtipo = usuario.ID_TIPOUSUARIO;
}
else
{
rm.SetResponse(false, "Usuario y/o Password incorrectos");
}
}
}
catch (Exception)
{
throw;
}
return(rm);
}
public ResponseModel Acceder(string Email, string Password)
{
try
{
using (var ctx = new CmsContext())
{
Password = HashHelper.MD5(Password);
var usuario = ctx.Usuario.Where(x => x.Email == Email)
.Where(x => x.Password == Password)
.SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.idUsuario.ToString());
rm.SetResponse(true);
}
else
{
rm.SetResponse(false, "Correo o contraseña incorrecta");
}
}
}
catch (Exception)
{
throw;
}
return(rm);
}
public ActionResult Authenticate(Login user)
{
if (!ModelState.IsValid)
{
return(View("Index"));
}
//Autenticar a Base de datos
ManagerLogin validate = new ManagerLogin();
var userinfo = validate.ValidateUser(user);
userinfo.userID = user.userName;
user.asesor = userinfo.asesor;
user.sucursal = userinfo.sucursal;
TempData["user"] = userinfo;
TempData["asesor"] = userinfo.asesor;
//Generar la cookie
if (userinfo.msg.errorCode.Equals("0"))
{
SessionHelper.AddUserToSession(userinfo.userName);
if (userinfo.url != string.Empty)
{
return(RedirectToAction("Index", userinfo.url, userinfo));
}
}
else
{
TempData["msg"] = userinfo.msg.errorMessage;
return(RedirectToAction("Index"));
}
System.Web.HttpContext.Current.Session["usr"] = user;
System.Web.HttpContext.Current.Session["menuType"] = validate.GetMenuType(user.userName);
return(RedirectToAction("MainMenu"));
}
public ActionResult Perfil(PerfilLoginModel model)
{
if (ModelState.IsValid)
{
// Ticket de cookie
CustomPrincipalTicket _dataTicket = new CustomPrincipalTicket
{
CID = User.CID,
Usuario = User.Usuario,
Unidad_Nombre = User.Unidad_Nombre,
OrganoServicio_CID = User.OrganoServicio_CID,
OrganoServicio_Nombre = User.OrganoServicio_Nombre,
OrganoServicio_Abr = User.OrganoServicio_Abr,
Rol_Accion = User.Rol_Accion,
Perfil_CID = model.Perfil.CID,
Perfil_Nombre = model.SelectPerfil
};
SessionHelper.DestroyUserSession();
JavaScriptSerializer serializer = new JavaScriptSerializer();
string userData = serializer.Serialize(_dataTicket);
SessionHelper.AddUserToSession(Peach.EncriptText(userData));
}
else
{
AddToastMessage("Error", "El modelo de datos de seleccion de perfil no es válido", BootstrapAlertType.danger);
}
return(RedirectToAction("Index", "Home"));
}
//VALIDAMOS LAS CREDENCIALES DEL USUARIO ANTES DE ACCEDER
public ResponseModel Acceder(string Email, string Password)
{
var responseModel = new ResponseModel();
try
{
using (var ctx = new AppContext()) //Habrimos la conexion
{
Password = HashHelper.MD5(Password); //Hasheamos la contraseña
//Busco el usuario en la base de datos, y la con clave hasheada
var usuario = ctx.Usuario.Where(x => x.Email == Email)
.Where(x => x.Password == Password)
.SingleOrDefault();
if (usuario != null) //Si el usuario existe
{
//Creo la sesion
SessionHelper.AddUserToSession(usuario.id.ToString());
responseModel.SetResponse(true);
}
else //Si no existe
{
responseModel.SetResponse(false, "Correo o contraseña incorrecta");
}
}
}
catch (Exception)
{
throw;
}
return(responseModel);
}
public JsonResult ValidarUsuario(string usuario, string clave)
{
try
{
if (string.IsNullOrWhiteSpace(usuario) || string.IsNullOrWhiteSpace(clave))
{
return(Json(new { Success = false, Message = "Debe de completar todos los campos." }));
}
var resultUsuario = _unit.Usuario.ValidarUsuario(usuario, clave);
if (resultUsuario == null)
{
return(Json(new { Success = false, Message = "Usuario y/o contraseña incorrecto." }));
}
SessionHelper.AddUserToSession(resultUsuario.id.ToString());
}
catch (Exception ex)
{
log.Error("Error Validar Usuario", ex);
return(Json(new { Error = true, Message = "Ocurrió un error al procesar solicitud." }));
}
return(Json(new { Success = true }));
}
public ActionResult Index(FormCollection frm)
{
AESCryptoManejador mnjAes = new AESCryptoManejador();
string usuario = frm["Correo"];
string pass = frm["Contraseña"];
//Verificar si el usuario existe
usuario objUsuario = _repoUsuarios.getPorCorreo(usuario);
if (objUsuario == null)
{
return(RedirectToAction("Index", "LogueoR", new { error = 1, mensaje = "El usuario no existe" }));
}
if (mnjAes.descifrar(objUsuario.Contraseña) != pass)
{
return(RedirectToAction("Index", "LogueoR", new { error = 1, mensaje = "La contraseña es incorrecta" }));
}
//if (objUsuario.Status != 1)
//{
// return RedirectToAction("Index", "Logueo", new { error = 1, mensaje = "Usuario bloqueado" });
//}
//Para agregar el usuario a la sesión
SessionHelper.AddUserToSession(objUsuario);
return(RedirectToAction("Index", "Home", new { error = 1, mensaje = "Por el momento no hay Home / se notificara cuando este listo" }));
}
public ResponseModel Acceder(string Email, string Password)
{
ResponseModel rm = new ResponseModel();
try
{
using (var ctx = new PortafolioModel())
{
Password = HashHelper.MD5(Password);
var usuario = ctx.Usuarios.Where(x => x.Email == Email)
.Where(x => x.Password == Password)
.SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.id.ToString());
rm.SetResponse(true);
}
else
{
rm.SetResponse(false, "Acceso denegado");
}
}
return(rm);
}
catch (Exception ex)
{
rm.SetResponse(false, ex.Message);
}
return(rm);
}
public static ResponseModel Acceder(this DbSet <Usuario> dbset, string Email, string password)
{
var rm = new ResponseModel();
try
{
using (var ctx = new Model1())
{
password = HashHelper.MD5(password);
var usuario = ctx.Usuario.Where(x => x.Email == Email)
.Where(x => x.Password == password)
.SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.UsuarioID.ToString());
rm.SetResponse(true);
}
else
{
rm.SetResponse(false, "Correo o Contraseña incorrecto.");
}
}
}
catch (Exception e)
{
throw;
}
return(rm);
}
public ActionResult Index(string email, string password, bool?recordar)
{
IRepository repository = new Model.Repository();
var objUsu = repository.FindEntity <Usuario>(c => c.CorreoElectronico == email && c.Activo == true);
int id = 0;
string strMensaje = "El usuario y/o contraseña son incorrectos.";
recordar = recordar == null ? false : true;
if (objUsu != null)
{
if (CryproHelper.Confirm(password, objUsu.Password, CryproHelper.Supported_HA.SHA512))
{
id = -1;
SessionHelper.AddUserToSession(objUsu.Id.ToString(), (bool)recordar);
SessionHelper.ActualizarSession(objUsu);
if (objUsu.Rol_Id == 1)
{
strMensaje = Url.Content("~/Home");
}
}
}
return(Json(new Response {
IsSuccess = true, Message = strMensaje, Id = id
}, JsonRequestBehavior.AllowGet));
}
public JsonResult IniciarSesion(UsuarioBE entidad)
{
ResponseEntity itemRespuesta = new ResponseEntity();
try
{
entidad = UsuarioLN.ObtenerPassword(entidad);
itemRespuesta.success = entidad.OK;
if (entidad.OK)
{
SessionHelper.AddUserToSession(entidad.ID_USUARIO.ToString());
Session["usuario"] = entidad.ID_USUARIO.ToString();
Session["socket"] = WebConfigurationManager.AppSettings.Get("Socket");
List <RolOpcionesBE> lista = RolOpcionesLN.ListarOpciones(entidad.ID_USUARIO);
limpiarSetearSesion(lista);
}
else
{
itemRespuesta.extra = entidad.extra;
}
}
catch (Exception ex)
{
Log.Error(ex);
itemRespuesta.success = false;
}
return(Respuesta(itemRespuesta));
}
public ActionResult Login(LoginFormViewModel form, string url)
{
if (ModelState.IsValid)
{
try
{
var token = _loginRepository.Login(form);
SessionHelper.AddUserToSession(token);
if (!string.IsNullOrEmpty(url))
{
return(Redirect(url));
}
return(RedirectToAction("Index", "Dashboard"));
}
catch (BadRequestException bre)
{
ModelState.AddModelError("", "Incorrect username and/or password");
}
}
return(View("Index", form));
}
public ResponseModel Autenticarse()
{
var rm = new ResponseModel();
try
{
using (var ctx = new ModeloProyecto())
{
var usuario = ctx.Users.Where(x => x.Email == this.Email && x.Password == this.Password).SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.Id.ToString());
rm.SetResponse(true);
}
else
{
rm.SetResponse(false);
}
}
}
catch
{
throw;
}
return(rm);
}
public ResponseModel Autenticarse()
{
var rm = new ResponseModel();
try
{
using (var ctx = new BaseDeDatosEntities())
{
var usuario = ctx.Usuarios.Where(x => x.Correo == this.Correo && x.Password == this.Password).SingleOrDefault();
if (usuario != null)
{
SessionHelper.AddUserToSession(usuario.id.ToString());
rm.SetResponse(true);
}
else
{
rm.SetResponse(false, "Acceso denegado al sistema");
}
}
}
catch (Exception e)
{
throw;
}
return(rm);
}
public ActionResult Index(Login model, bool?backend)
{
if (ModelState.IsValid)
{
var user = _bl.ValidarUser(model.cEmail, model.cPassword);
if (user != null)
{
SessionHelper.AddUserToSession(user);
if (model.isRememberMe)
{
SessionHelper.AddCookieToClave(user.pkUsuario.ToString());
}
return(RedirectToAction("Index", backend == null ? "Home":"Dashboard"));
}
ModelState.AddModelError("ErrorSesion", "El usuario o la contraseña ingresados no son correctos");
}
if (backend == null)
{
return(RedirectToAction("Index", "Home", new { ErrorSesion = "El usuario o la contraseña ingresados no son correctos" }));
}
return(View(model));
}
public ActionResult Index(Usuarios objUser)
{
if (ModelState.IsValid)
{
using (AppDBContext db = new AppDBContext())
{
try
{ //a.deleted_at.Equals(null) para no dejar pasar a los eliminados
var obj = db.Usuarios
.Where(a => a.usuario.Equals(objUser.usuario) && a.clave.Equals(objUser.clave) && a.deleted_at.Equals(null))
.FirstOrDefault();
if (obj != null)
{
SessionHelper.AddUserToSession(obj.idUsuario.ToString());
return(RedirectToAction("UserDashBoard"));
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
}
ViewBag.Message = "Usuario o clave incoreccto";
return(View(objUser));
}
public ResponseModel Acceder(ELUsuario usuario)
{
try
{
// Encriptamos la contraseña para comparar
usuario.Password = HashHelper.MD5(usuario.Password);
var _usuario = dl.DL_Autenticar(usuario);
if (_usuario != null)
{
SessionHelper.AddUserToSession(_usuario.Id.ToString());
rm.SetResponse(true);
rm.href = "inicio";
}
else
{
rm.SetResponse(false, "El usuario ingresado no existe");
}
}
catch (Exception e)
{
ELog.Save(this, e);
}
return(rm);
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
base.OnActionExecuting(filterContext);
if (SessionHelper.ExistUserInSession())
{
if (!IsAdmin)
{
return;
}
var user = (Usuario)SessionHelper.GetUser();
if (user.isAdmin)
{
return;
}
}
if (SessionHelper.ExistCookieSession())
{
var user = new UsuarioBl().Get(int.Parse(SessionHelper.GetCookie()));
if (IsAdmin)
{
if (user.isAdmin)
{
SessionHelper.AddUserToSession(user);
return;
}
if (Optional)
{
return;
}
filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary(new
{
controller = "Login",
action = "Index"
}));
}
else
{
SessionHelper.AddUserToSession(user);
}
}
else
{
if (Optional)
{
return;
}
filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary(new
{
controller = "Login",
action = "Index"
}));
}
}
public JsonResult IniciarSesion(UsuarioBE entidad)
{
ResponseEntity itemRespuesta = new ResponseEntity();
try
{
var _GoogleRecaptcha = _GoogleReCAPTCHAService.VerifyRecaptcha(entidad.Token);
if (!_GoogleRecaptcha.Result.success && _GoogleRecaptcha.Result.score <= 0.5)
{
itemRespuesta.success = false;
itemRespuesta.extra = "Usted no es una entidad válida (You are Not Human ....)";
}
else
{
//if (Membership.ValidateUser(entidad.USUARIO, entidad.PASSWORD_USUARIO))
//{
// entidad = UsuarioLN.ObtenerPassword(entidad);
// itemRespuesta.success = entidad.OK;
// //itemRespuesta.success = true;
// Session["usuario"] = entidad.ID_USUARIO.ToString();
// Session["socket"] = WebConfigurationManager.AppSettings.Get("Socket");
// List<RolOpcionesBE> lista = RolOpcionesLN.ListarOpciones(entidad.ID_USUARIO);
// limpiarSetearSesion(lista);
// FormsAuthentication.RedirectFromLoginPage(entidad.USUARIO, false);
// return null;
//}
//else
//{
// itemRespuesta.extra = entidad.extra;
//}
entidad = UsuarioLN.ObtenerPassword(entidad);
itemRespuesta.success = entidad.OK;
if (entidad.OK)
{
SessionHelper.AddUserToSession(entidad.ID_USUARIO.ToString());
Session["usuario"] = entidad.ID_USUARIO.ToString();
Session["socket"] = WebConfigurationManager.AppSettings.Get("Socket");
List <RolOpcionesBE> lista = RolOpcionesLN.ListarOpciones(entidad.ID_USUARIO);
limpiarSetearSesion(lista);
}
else
{
itemRespuesta.extra = entidad.extra;
}
}
}
catch (Exception ex)
{
Log.Error(ex);
itemRespuesta.success = false;
}
return(Respuesta(itemRespuesta));
}
public ActionResult Autentificar(UsuarioModel usuario)
{
if (ModelState.IsValid)
{
// Guardamos un usuario en SESSION, en teoría tiene el ID número 2001
SessionHelper.AddUserToSession(usuario.Email);
}
return(Redirect("~/"));
}
public async Task <ActionResult> login(MvReCAPTCHASettings model)
{
UsuarioBE entidad = new UsuarioBE()
{
USUARIO = model.USUARIO, PASSWORD_USUARIO = model.PASSWORD_USUARIO
};
try
{
//GoogleResponse _GoogleRecaptcha = await GoogleReCAPTCHAService.VerifyRecaptcha(entidad.Token);
var isCaptchaValid = await IsCaptchaValid(model.TOKEN);
if (isCaptchaValid)
{
entidad = UsuarioLN.ObtenerPassword(entidad);
if (entidad.OK)
{
SessionHelper.AddUserToSession(entidad.ID_USUARIO.ToString());
Session["usuario"] = entidad.ID_USUARIO.ToString();
Session["socket"] = WebConfigurationManager.AppSettings.Get("Socket");
List <RolOpcionesBE> lista = RolOpcionesLN.ListarOpciones(entidad.ID_USUARIO);
limpiarSetearSesion(lista);
return(new RedirectToRouteResult(new RouteValueDictionary(new
{
controller = "Gestion",
action = "AccionMitigacion"
})));
}
else
{
model.OK = false;
model.extra = entidad.extra;
}
}
else
{
model.OK = false;
model.extra = "El Captcha no es válido";
return(new RedirectToRouteResult(new RouteValueDictionary(new
{
controller = "Home",
action = "login"
})));
}
}
catch (Exception ex)
{
Log.Error(ex);
}
return(View(model));
}
public ActionResult Autenticar(string user, string pass)
{
var aut = UsuarioBL.Obtener(x => x.Nombre == user && x.Clave == pass);
if (aut == null)
{
return(RedirectToAction("Login", "Home", new { error = "Error en Usuario o Contraseña" }));
}
SessionHelper.AddUserToSession(aut.UsuarioId.ToString());
return(RedirectToAction("Index", "Home"));
}
public ActionResult Acceder(string Usuario, string Password)
{
var rm = login.Acceder(Usuario, Password);
if (rm.response)
{
var aux = Json(rm.result);
SessionHelper.AddUserToSession(aux);
rm.href = Url.Content("~/tareas");
rm.result = null;
}
return(Json(rm));
}
private void Start_Session(string UserName = null, string Password = null)
{
UserController us = new UserController();
User model = us.Get_User_By_User_Password(UserName, Password);
if (model != null)
{
SessionHelper.AddUserToSession(model.id.ToString());
SessionHelper.AddNewSession("NAME_USER", (model.name + " " + model.last_name));
SessionHelper.AddNewSession("ROL_ID", model.id_rol.ToString());
SessionHelper.AddNewSession("ROL_USER", model.name_rol);
SessionHelper.AddNewSession("MENU_PERMISSIONS", Menu_Permissions(model.id_rol));
}
}
public ActionResult Autenticar(string login_name, string login_pw, string tk)
{
var rm = new Web.Models.ResponseModel();
//if (tk != ConfigurationManager.AppSettings["tk"].ToString())
// return Content("No Autorizado");
int oficinaId = int.Parse(Request.Form["cboOficina"]);
var usuarioOficina = UsuarioOficinaBL.Listar(x => x.Usuario.NombreUsuario == login_name && x.Usuario.ClaveUsuario == login_pw &&
x.OficinaId == oficinaId && x.Estado && x.Usuario.Estado, null, "Usuario,Oficina").FirstOrDefault();
if (usuarioOficina != null)
{
SessionHelper.AddUserToSession(usuarioOficina.UsuarioId.ToString());
rm.SetResponse(true);
rm.href = Url.Action("Index", "Home");
VendixGlobal <int> .Crear("UsuarioOficinaId", usuarioOficina.UsuarioOficinaId);
VendixGlobal <int> .Crear("BovedaId", BovedaBL.Listar(x => x.OficinaId == oficinaId, y => y.OrderByDescending(z => z.FechaIniOperacion)).First().BovedaId);
//usuario asginado a oficina
var usuarioAsignadoId = OficinaBL.Obtener(x => x.OficinaId == usuarioOficina.OficinaId && x.Estado).UsuarioAsignadoId;
VendixGlobal <int> .Crear("UsuarioIdAsignadoOficina", usuarioAsignadoId);
VendixGlobal <int> .Crear("UsuarioId", usuarioOficina.UsuarioId);
VendixGlobal <string> .Crear("NombreUsuario", usuarioOficina.Usuario.NombreUsuario);
VendixGlobal <string> .Crear("NombreOficina", usuarioOficina.Oficina.Denominacion);
VendixGlobal <int> .Crear("OficinaId", usuarioOficina.OficinaId);
VendixGlobal <List <usp_MenuLst_Result> > .Crear("Menu", MenuBL.ListaMenuDinamico());
//System.Web.HttpContext.Current.Cache.Insert("Menu", MenuBL.ListaMenuDinamico());
//var x = HttpRuntime.Cache.Get("Menu") as List<usp_MenuLst_Result>;
//return RedirectToAction("Index");
}
else
{
rm.SetResponse(false, "Usuario o Clave Incorrecta");
}
return(Json(rm));
//return RedirectToAction("Login", new { id = tk, mensaje = "Usuario o Clave Incorrecto" });
}
//add
public async Task <JsonResult> ValidarCaptcha(MvReCAPTCHASettings model)
{
ResponseEntity itemRespuesta = new ResponseEntity();
UsuarioBE entidad = new UsuarioBE()
{
USUARIO = model.USUARIO, PASSWORD_USUARIO = model.PASSWORD_USUARIO
};
try
{
//GoogleResponse _GoogleRecaptcha = await GoogleReCAPTCHAService.VerifyRecaptcha(entidad.Token);
var isCaptchaValid = await IsCaptchaValid(model.TOKEN);
if (isCaptchaValid)
{
entidad = UsuarioLN.ObtenerPassword(entidad);
if (entidad.OK)
{
SessionHelper.AddUserToSession(entidad.ID_USUARIO.ToString());
Session["usuario"] = entidad.ID_USUARIO.ToString();
Session["socket"] = WebConfigurationManager.AppSettings.Get("Socket");
List <RolOpcionesBE> lista = RolOpcionesLN.ListarOpciones(entidad.ID_USUARIO);
limpiarSetearSesion(lista);
itemRespuesta.success = true;
}
else
{
itemRespuesta.extra = entidad.extra;
itemRespuesta.success = false;
}
}
else
{
itemRespuesta.extra = "El Captcha no es válido";
itemRespuesta.success = false;
}
}
catch (Exception ex)
{
Log.Error(ex);
itemRespuesta.extra = "Usuario y/o Password incorrecto";
itemRespuesta.success = false;
}
return(Respuesta(itemRespuesta));
}
}//recuperarUsuarioPorCedula
#endregion Busquedas
#region Iniciar Sesion
public static Usuarios validarInicioSesion(string nombreUsuario, string contrasena)
{
contrasena = HashHelper.MD5(contrasena);
inventarioEntidadesDB contextoConexionBusqueda = new inventarioEntidadesDB();
Usuarios objetoUsuarios = contextoConexionBusqueda.Usuarios.Where(x => x.Usuario == nombreUsuario)
.Where(x => x.Contrasenia == contrasena)
.Where(x => x.Activar == 1).FirstOrDefault();
if (objetoUsuarios != null)
{
SessionHelper.AddUserToSession(objetoUsuarios.idUsuario.ToString());
}
return(objetoUsuarios);
}//recuperarListaUsuarios
public ResponseModel Autenticarse()
{
var rm = new ResponseModel();
try
{
string passwordEncriptado = Seguridad.Encriptar(this.Password);
//passwordEncriptado = "UABhAHMAcwB3AG8AcgBkADEA";
var usuario = db.Usuarios.Where(x => x.NombreUsuario == this.NombreUsuario).SingleOrDefault();
if (usuario != null)
{
if (usuario.EsBloqueado)
{
rm.SetResponse(false, "Su cuenta a sido bloqueada. El administrador del sistema debe restablecer su password y activar su cuenta");
}
else if (usuario.Password == passwordEncriptado)
{
usuario.IntentosFallidos = 0;
usuario.ConfirmarPassword = usuario.Password;
db.SaveChanges();
SessionHelper.AddUserToSession(usuario.UsuarioID.ToString());
rm.SetResponse(true);
}
else
{
usuario.IntentosFallidos = usuario.IntentosFallidos + 1;
usuario.ConfirmarPassword = usuario.Password;
if (usuario.IntentosFallidos >= 3)
{
usuario.EsBloqueado = true;
}
db.SaveChanges();
rm.SetResponse(false, "Acceso denegado al sistema");
}
}
else
{
rm.SetResponse(false, "Nombre de usuario y/o Password son incorrectos");
}
}
catch (Exception e)
{
throw;
}
return(rm);
}
public ActionResult Login([Bind(Include = "UserName,Password")] User _user)
{
var user = _userService.FindbyUserName(_user.UserName);
if (user == null)
{
//mensaje de error
}
else
{
if (user.Password != _user.Password || user.UserName != _user.UserName)
{
return(View());;
}
}
SessionHelper.AddUserToSession(user.Id.ToString());
return(RedirectToAction("Index", "Inicio"));
}
public static Usuario Acceder(string Email, string Password)
{
var user = new Usuario();
Password = HashHelper.MD5(Password);
try
{
NpgsqlConnection cnn;
cnn = new NpgsqlConnection(connectionString);
cnn.Open();
NpgsqlCommand command;
NpgsqlDataReader dataReader;
string sql, Output = string.Empty;
sql = $"Select d.id, d.idinstitucion, d.nombre, d.apellido, d.idrol from dbo.usuario d where d.email = '{Email}' and d.contrasenha = '{Password}'";
command = new NpgsqlCommand(sql, cnn);
dataReader = command.ExecuteReader();
while (dataReader.Read())
{
string idusuario = dataReader.GetValue(0).ToString();
string institucion = dataReader.GetValue(1).ToString();
string nombre = dataReader.GetValue(2).ToString();
string apellido = dataReader.GetValue(3).ToString();
string rol = dataReader.GetValue(4).ToString();
user.ID = long.Parse(idusuario);
user.IDInstitucion = long.Parse(institucion);
user.Nombre = nombre;
user.Apellido = apellido;
user.IDRol = long.Parse(rol);
SessionHelper.AddUserToSession(user, institucion);
}
command.Dispose(); cnn.Close();
}
catch (Exception e)
{
}
return(user);
}