public ActionResult Perfil(PerfilViewModel model)
{
ViewBag.Title = Resources.PerfilResource.PageTitle;
ViewBag.PageHeader = Resources.PerfilResource.HeaderPage;
ViewBag.ShowMenu = false;
if (!ModelState.IsValid)
{
return(View(model));
}
FormsAuthenticationTicket encTicket = FormsAuthentication.Decrypt(Session["user"].ToString());
CustomPrincipalSerializeModel serializeModel = JsonConvert.DeserializeObject <CustomPrincipalSerializeModel>(encTicket.UserData);
using (SeguricelEntities db = new SeguricelEntities())
{
Usuario _dataUsuario = (from u in db.Usuario
where u.IdUsuario == serializeModel.Id
select u).FirstOrDefault();
if (_dataUsuario != null)
{
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
string encryptedPassword = Encrypt.Encriptar(model.Password, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
_dataUsuario.ClaveUsuario = encryptedPassword;
_dataUsuario.Email = model.Email;
_dataUsuario.Pregunta1 = model.Pregunta1;
_dataUsuario.Respuesta1 = model.Respuesta1;
_dataUsuario.Pregunta2 = model.Pregunta2;
_dataUsuario.Respuesta2 = model.Respuesta2;
_dataUsuario.Pregunta3 = model.Pregunta3;
_dataUsuario.Respuesta3 = model.Respuesta3;
/*
* Guardar datos
*/
db.Database.ExecuteSqlCommand(
"update Usuario set ClaveUsuario=@p0, Email=@p1, Pregunta1=@p2, " +
"Respuesta1 = @p3, Pregunta2 = @p4, Respuesta2 = @p5, Pregunta3 = @p6, Respuesta3 = @p7, PrimeraVez=0, CodigoUsuario=@p8 where CodigoUsuario=@p1 or Email=@p1 ",
new SqlParameter("@p0", encryptedPassword),
new SqlParameter("@p1", model.Email),
new SqlParameter("@p2", model.Pregunta1),
new SqlParameter("@p3", model.Respuesta1),
new SqlParameter("@p4", model.Pregunta2),
new SqlParameter("@p5", model.Respuesta2),
new SqlParameter("@p6", model.Pregunta3),
new SqlParameter("@p7", model.Respuesta3),
new SqlParameter("@p8", model.Apodo));
return(ConectarUsuario(_dataUsuario, db));
}
}
return(View(model));
}
public bool VerificarPassword()
{
Encriptador encriptador = new Encriptador();
if (encriptador.Encriptar(txtPasswordAnterior.Text) == Usuario.Password)
{
txtPasswordAnterior.BackColor = Color.White;
lblPassword.Text = "Los campos de contraseña no son iguales.";
if (txtPassword.Text.Trim() == txtPassword2.Text.Trim() && txtPassword.Text.Trim() != "")
{
txtPassword.BackColor = Color.White;
txtPassword2.BackColor = Color.White;
lblPassword.Visible = false;
return(true);
}
else
{
txtPassword.BackColor = Color.HotPink;
txtPassword2.BackColor = Color.HotPink;
lblPassword.Visible = true;
return(false);
}
}
else
{
txtPasswordAnterior.BackColor = Color.HotPink;
lblPassword.Text = "La contraseña antigua no es correcta.";
lblPassword.Visible = true;
return(false);
}
}
public ActionResult Index(string key)
{
Encriptador Enc = new Encriptador();
string datos = Enc.Desencriptar(key);
string[] admin = Regex.Split(datos, "@@");
string _key = Enc.Encriptar(admin[0]);
Session["admin"] = _key;
Session["nombre"] = admin[1];
/*if (Session["admin"] == null)
* {
* Response.Redirect("/login");
* }*/
ListadoArticulos data = new ListadoArticulos();
data.generaListado(Server.UrlEncode(_key).ToString(), 0);
ViewBag.listado = data;
ViewBag.nombre = Session["nombre"];
ViewBag.session = Session["admin"];
ViewBag.key = key;
return(View());
}
/// <summary>
///
/// </summary>
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
Encriptador _Encriptador = new Encriptador();
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
tblUsuario user;
using (Entities _repo = new Entities())
{
string _encriptedPassword = _Encriptador.Encriptar(context.Password, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
//string _encriptedPassword = context.Password;
user = await _repo.tblUsuario.FirstOrDefaultAsync(x => x.Email == context.UserName && x.ClaveUsuario == _encriptedPassword);
if (user == null)
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
return;
}
}
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim("Nombre", user.Nombre));
identity.AddClaim(new Claim("Id", user.IdUsuario.ToString()));
context.Validated(identity);
}
private Usuario ObtenerUsuarioFormulario()
{
try
{
//Si es un Alta
if (usuario == null)
{
usuario = new Usuario();
}
else
{
usuario.FechaUltimaModificacion = DateTime.Now; // Ver si tiene que ser parametro de configuración.
}
string blancoEncriptado = Encriptador.Encriptar(string.Empty);
usuario.Username = txtUsername.Text;
if (Encriptador.Encriptar(txtPassword.Text) != blancoEncriptado)
{
usuario.Password = Encriptador.Encriptar(txtPassword.Text);
}
usuario.PreguntaSecreta = txtPregunta.Text;
if (Encriptador.Encriptar(txtRespuesta.Text) != blancoEncriptado)
{
usuario.RespuestaSecreta = Encriptador.Encriptar(txtRespuesta.Text);
}
usuario.Inhabilitado = chkInhabilitado.Checked;
usuario.FechaCreacion = (lblFechaCreacion.Text != string.Empty) ? Convert.ToDateTime(lblFechaCreacion.Text) : DateTime.MinValue;
usuario.Roles = (List <Rol>)lstAsignados.DataSource;
return(usuario);
}
catch (Exception ex)
{
throw ex;
}
}
public Usuario ResetearContrasena(Usuario usuario, string contrasenaNueva)
{
usuario.Estado = ESTADO_DESHABILITADO;
usuario.Reintento = 0;
usuario.Contrasena = Encriptador.Encriptar(contrasenaNueva);
return(usuarioBll.Modificar(usuario));
}
public RespuestaAtenticacion Autenticar(Usuario usuario)
{
Dictionary <string, object> p = new Dictionary <string, object>
{
{ "alias", usuario.Alias }
};
Usuario usuarioEncontrado = usuarioBll.Buscar(p);
if (usuarioEncontrado == null)
{
return(respuestas[RESPUESTA_INCORRECTO]);
}
if (usuarioEncontrado.Estado == ESTADO_DESHABILITADO)
{
return(respuestas[RESPUESTA_DESHABILITADO]);
}
if (usuarioEncontrado.Contrasena == Encriptador.Encriptar(usuario.Contrasena))
{
usuarioEncontrado.Reintento = 0;
usuarioBll.Modificar(usuarioEncontrado);
return(respuestas[RESPUESTA_CORRECTO]);
}
else
{
AumentarReintentos(usuarioEncontrado);
return(respuestas[RESPUESTA_INCORRECTO]);
}
}
public IActionResult UserLogin([FromForm] UsuarioConsultaDto objUsuarioConsultaDto)
{
objUsuarioConsultaDto.Password = Encriptador.Encriptar(objUsuarioConsultaDto.Password);
if (string.IsNullOrWhiteSpace(objUsuarioConsultaDto.Password))
{
ViewBag.Error = "Ingrese Usuario o Contraseña";
return(View("Index"));
}
HttpContext.Session.SetString("Usu", objUsuarioConsultaDto.Usuarios);
HttpContext.Session.SetString("Pas", objUsuarioConsultaDto.Password);
try
{
objUsuarioConsultaDto = _Usuario.UsuarioLogin(objUsuarioConsultaDto);
if (string.IsNullOrEmpty(objUsuarioConsultaDto.Correo))
{
ViewBag.Error = "Usuario o Contraseña Incorrecto";
UsuarioLoginDto objUsuarioLoginDto = new UsuarioLoginDto();
objUsuarioLoginDto.Tipo = "Login";
return(View("Index", objUsuarioLoginDto));
}
GenerateTicketAuthentication(objUsuarioConsultaDto);
Log.Information("INICIO");
HttpContext.Session.SetString("_TipoEmpresa", GetPerfil());
// HttpContext.Session.SetString("_TipoEmpresa",objUsuarioConsultaDto.TipoEmpresa);
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
Log.Error(ex.Message);
ViewBag.Error = "Usuario o Contraseña Incorrecto";
return(View("Index"));
}
}
public ActionResult EditUsuario(Guid id)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
{
return(RedirectToAction("Index", "Home"));
}
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
UsuarioViewModel model = new UsuarioViewModel();
using (SeguricelEntities db = new SeguricelEntities())
{
Encriptador Encrypt = new Encriptador();
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
Usuario usuario = (from d in db.Usuario
where d.IdUsuario == id
select d).FirstOrDefault();
string decryptedPassword = Encrypt.Encriptar(usuario.ClaveUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
if (usuario != null)
{
model.ConfirmPasswordUsuario = decryptedPassword;
model.EmailUsuario = usuario.Email;
model.Estado = usuario.IdEstadoUsuario;
model.Id = usuario.IdUsuario;
model.IdTipoUsuario = usuario.IdTipoUsuario;
model.Nombre = usuario.Nombre;
model.PasswordUsuario = decryptedPassword;
}
}
return(View(model));
}
public IActionResult MantenimientoParametros([FromForm] ParametrosCorreoDto objParametrosCorreoDto)
{
var jsonResponseDto = new JsonResponseDto();
try
{
objParametrosCorreoDto.Password = Encriptador.Encriptar(objParametrosCorreoDto.Password);
var message = (objParametrosCorreoDto.IdParametros == null) ? Constante.registroExitoso : Constante.actualizacionExitoso;
objParametrosCorreoDto.IdParametros = (objParametrosCorreoDto.IdParametros == null) ? "" : objParametrosCorreoDto.IdParametros;
objParametrosCorreoDto.Password = (objParametrosCorreoDto.Password == null) ? "" : objParametrosCorreoDto.Password;
var response = _Empresa.MantenimientoParametrosCorreo(objParametrosCorreoDto);
if (response >= 1)
{
jsonResponseDto.Type = Constante.Success.ToLower();
jsonResponseDto.IsValid = true;
jsonResponseDto.Mensaje = message;
}
else
{
// Log.Error(response.Content.ToString());
jsonResponseDto.Type = Constante.Warning.ToLower();
jsonResponseDto.IsValid = false;
jsonResponseDto.Mensaje = Constante.registroError;
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
jsonResponseDto.Type = Constante.Warning.ToLower();
jsonResponseDto.IsValid = false;
jsonResponseDto.Mensaje = ex.Message.ToString();
}
return(Json(jsonResponseDto));
}
public JsonResult Crear(UsuarioDto userDto)
{
var response = new JsonResponse { Success = false };
var entityTemp = _usuarioBl.Get(p => p.UserName == userDto.UserName && p.Estado == (int)TipoEstado.Activo);
if (entityTemp == null)
{
var userDomain = MapperHelper.Map<UsuarioDto, Usuario>(userDto);
Guid guid = Guid.NewGuid();
var password = guid.ToString().Split('-')[1];
userDomain.Password = Encriptador.Encriptar(password);
_usuarioBl.Add(userDomain);
response.Message = "Se registró el usuario correctamente";
response.Success = true;
}
else
{
response.Message = "Ya existe el nombre de usuario";
response.Success = false;
}
return Json(response, JsonRequestBehavior.AllowGet);
}
// para la autenticacion
public void UserRepositoryAccess(string login, string password)
{
access = new Access();
decimal user_id = 0;
string user_email = "";
int user_error = 1;
string code_error = "";
string user_nombre = "";
string valor1 = "";
string valor2 = "";
string key = "";
String _query = "exec sp_login '" + login + "','" + password + "' ";
BaseDatos conexion = new BaseDatos("SQL"); //Creando objetos de la base de datos
conexion.Conectar();
conexion.CrearComando(_query); //Comando indica que quiero encontrar
DbDataReader DRConexion = conexion.EjecutarConsulta();
while (DRConexion.Read())
{
user_id = DRConexion.GetDecimal(0);
user_email = DRConexion.GetString(1);
user_error = DRConexion.GetInt32(2);
user_nombre = DRConexion.GetString(3);
}
conexion.Desconectar();
// procesamos token
if (user_id > 0)
{
valor1 = "{\"personaid\":\"" + user_id + "\", \"email\":\"" + user_email + "\", \"error\":\"" + user_error + "\", \"nombre\":\"" + user_nombre + "\"}";
valor2 = "enia2013";
// encriptamos el valor
Encriptador enc = new Encriptador();
valor1 = enc.Encriptar(valor1);
//valor2 = enc.Encriptar(valor2);
key = valor1 + "_" + valor2;
}
if (user_error != 0)
{
code_error = "Invalid AccessToken";
key = "";
}
else
{
code_error = "Valid AccessToken";
}
access = new Access
{
//userID = DRConexion.GetDecimal(0),
token = key.Replace("+", "%2B").Replace("/", "%2F"),
codigo = code_error
};
}
static void Main()
{
string encriptado = Encriptador.Encriptar("Hola");
string desencriptado = Encriptador.Desencriptar("Ipmb");
Console.WriteLine("Palabra encriptada: {0}", encriptado);
Console.WriteLine("Palabra desencriptada: {0}", desencriptado);
}
static void Main()
{
string encriptadoCesar = EncriptadorCesar.Encriptar("Holz");
string encriptado = Encriptador.Encriptar("Holz");
string desencriptadoCesar = EncriptadorCesar.Desencriptar("Holz");
string desencriptado = Encriptador.Desencriptar("Holz");
Console.WriteLine("Palabra encriptada cesar: {0}", encriptadoCesar);
Console.WriteLine("Palabra encriptada: {0}", encriptado);
Console.WriteLine("Palabra desencriptada cesar: {0}", desencriptadoCesar);
Console.WriteLine("Palabra desencriptada: {0}", desencriptado);
}
private void ValidarDatosUsuario(Usuario usuarioLogueado)
{
if (!usuarioLogueado.Inhabilitado)
{
string paswordIngresadoEncriptado = Encriptador.Encriptar(txtPassword.Text);
bool logueoCorrecto = usuarioLogueado.Password == paswordIngresadoEncriptado;
Negocio.Helpers.UtilNegocio util = new PagoElectronico.Negocio.Helpers.UtilNegocio();
if (logueoCorrecto)
{
util.GuardarAuditoriaLogin(usuarioLogueado.Username, logueoCorrecto, usuarioLogueado.CantidadIntentosFallidos + 1);
ReiniciarIntentosFallidos(usuarioLogueado);
//Solo roles habilitados
usuarioLogueado.Roles = usuarioLogueado.Roles.Where(r => !r.Estado).ToList();
if (usuarioLogueado.Roles != null && usuarioLogueado.Roles.Count > 0)
{
if (usuarioLogueado.Roles.Count > 1)
{
PrepararSeleccionRoles();
}
else
{
usuarioLogueado.RolActivo = usuarioLogueado.Roles[0];
MostrarMenu(usuarioLogueado);
}
}
else
{
MessageBox.Show("El usuario [" + txtUsername.Text + "] no tiene roles habilitados asignados. Por favor comuniquese con el Administrador del sistema.", "Login", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else
{
RegistrarIntentoFallido(usuarioLogueado);
util.GuardarAuditoriaLogin(usuarioLogueado.Username, logueoCorrecto, usuarioLogueado.CantidadIntentosFallidos);
if (usuarioLogueado.Inhabilitado)
{
MessageBox.Show("El usuario [" + txtUsername.Text + "] fué Inhabilitado por superar la cantidad de intentos fallidos(3). Por favor comuniquese con el Administrador del sistema.", "Login", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
MostrarMensajeErrorLogin();
}
}
}
else
{
MessageBox.Show("El usuario [" + txtUsername.Text + "] se encuentra Inhabilitado para usar el sistema. Por favor comuniquese con el Administrador del sistema.", "Login", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
private void AgregarRegistrosUsuario(DbContext context)
{
var usuario = new Usuario
{
UserName = "******",
Password = Encriptador.Encriptar("1234"),
Email = "*****@*****.**",
Estado = TipoEstado.Activo.GetNumberValue(),
Rol = _rolAdmin
};
context.Set <Usuario>().Add(usuario);
}
public Usuario ValidateUser(string username, string password)
{
Usuario user = Get(p => p.UserName == username && p.Estado == (int)TipoEstado.Activo);
if (user?.UserName == null)
{
return(null);
}
string enc = Encriptador.Encriptar(password);
return(enc == user.Password ? user : null);
}
static void Main()
{
Encriptador e = new Encriptador();
string fileName = "dup.txt";
Queue <string> queue1 = new Queue <string>(
File.ReadAllLines(fileName));
int total = queue1.Count;
for (int i = 0; i < total; i++)
{
Console.WriteLine(e.Encriptar(queue1.Dequeue()));
}
}
public ActionResult CreateUsuario(UsuarioViewModel model)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
{
return(RedirectToAction("Index", "Home"));
}
if (!ModelState.IsValid)
{
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
return(View(model));
}
using (SeguricelEntities db = new SeguricelEntities())
{
Encriptador Encrypt = new Encriptador();
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
string encryptedPassword = Encrypt.Encriptar(model.PasswordUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
Usuario usuario = new Usuario
{
ClaveUsuario = encryptedPassword,
Email = model.EmailUsuario,
CodigoUsuario = string.Empty,
FechaCambioEstatus = DateTime.UtcNow,
FechaUltimaConexion = DateTime.UtcNow,
IdEstadoUsuario = (int)eEstadoUsuario.Activo,
IdTipoUsuario = model.IdTipoUsuario,
IdUsuario = Guid.NewGuid(),
Nombre = model.Nombre,
Pregunta1 = string.Empty,
Pregunta2 = string.Empty,
Pregunta3 = string.Empty,
PrimeraVez = true,
Respuesta1 = string.Empty,
Respuesta2 = string.Empty,
Respuesta3 = string.Empty
};
db.Usuario.Add(usuario);
db.SaveChanges();
ClasesVarias.AddBitacoraUsuario(db,
"Usuario para " + model.Nombre,
105000001,
"Agregar");
}
return(RedirectToAction("Usuarios"));
}
protected void Page_Load(object sender, EventArgs ee)
{
IList <Hotel> hoteles = hotelBll.BuscarTodos();
Hotel h = hotelBll.BuscarPorId(2);
Evento e = new Evento();
e.Autor = "Dago";
e.Modulo = "hash";
e.Descripcion = Encriptador.Encriptar("hi");
bitacora.RegistrarEvento(e);
IPatente patente = autorizacionBll.ObtenerPatentePorUsuario(usuarioBll.BuscarPorId(1));
IList <Usuario> usuarios = usuarioBll.BuscarTodos();
}
public void ActualizarUsuario()
{
Usuario Actualizacion = new Usuario();
Encriptador encriptador = new Encriptador();
if (txtEmail.Text.Trim() != "")
{
Actualizacion.Email = txtEmail.Text;
}
else
{
Actualizacion.Email = Usuario.Email;
}
if (txtPassword.Text.Trim() != "")
{
Actualizacion.Password = txtPassword.Text;
}
else
{
Actualizacion.Password = encriptador.Desencriptar(Usuario.Password);
}
Actualizacion.ID_Usuario = Usuario.ID_Usuario;
Actualizacion.Nombres = txtNombre.Text;
Actualizacion.Apellidos = txtApellido.Text;
Actualizacion.DNI = Convert.ToInt32(txtDNI.Text);
Actualizacion.Domicilio.Provincia = ListaProvincias.SelectedValue;
Actualizacion.Domicilio.Ciudad = txtCiudad.Text;
Actualizacion.Domicilio.Calle = txtCalle.Text;
Actualizacion.Domicilio.Numero = Convert.ToInt32(txtNumero.Text);
Actualizacion.Domicilio.Piso = txtPiso.Text;
Actualizacion.Domicilio.CodigoPostal = Convert.ToInt32(txtCodigoPostal.Text);
Actualizacion.Domicilio.Departamento = txtDepartamento.Text;
Actualizacion.Domicilio.Referencia = txtReferencia.Text;
Actualizacion.TipoUsuario = Usuario.TipoUsuario;
Actualizacion.Telefono = Convert.ToInt32(txtTelefono.Text);
Actualizacion.Activo = Usuario.Activo;
Actualizacion.IDListaFavoritos = Usuario.IDListaFavoritos;
Actualizacion.ListaFavoritos = Usuario.ListaFavoritos;
NegocioABM negocioABM = new NegocioABM();
negocioABM.UsuarioModificacion(Actualizacion);
Actualizacion.Password = encriptador.Encriptar(Actualizacion.Password);
Session["Usuario" + Session.SessionID] = Actualizacion;
}
public JsonResult Modificar(Usuario usuario)
{
var jsonResponse = new JsonResponse();
if (ModelState.IsValid)
{
try
{
var usuarioOriginal = UsuarioBL.Instancia.Single(usuario.IdEmpleado);
usuarioOriginal.Username = usuario.Username;
usuarioOriginal.Password = Encriptador.Encriptar(usuario.Password);
usuarioOriginal.IdRol = usuario.IdRol;
usuarioOriginal.UsuarioSucursal = new List <UsuarioSucursal>();
usuarioOriginal.Estado = usuario.Estado;
foreach (var sucursal in usuario.Sucursales)
{
if (sucursal.Seleccionado)
{
usuarioOriginal.UsuarioSucursal.Add(new UsuarioSucursal
{
IdSucursal = sucursal.IdSucursal,
IdEmpleado = usuario.IdEmpleado
});
}
}
usuarioOriginal.FechaModiifacion = FechaModificacion;
usuarioOriginal.UsuarioModificacion = UsuarioActual.IdEmpleado;
UsuarioBL.Instancia.Update(usuarioOriginal);
jsonResponse.Success = true;
jsonResponse.Message = "Se Proceso con exito";
}
catch (Exception ex)
{
jsonResponse.Message = ex.Message;
}
}
else
{
jsonResponse.Message = "Por favor ingrese todos los campos requeridos";
}
return(Json(jsonResponse, JsonRequestBehavior.AllowGet));
}
public int AgregarUsuario(UsuarioDTO p_UsuarioDTO)
{
try
{
Perfil entityPerfil = this._perfilRepository.GetById(p_UsuarioDTO.PerfilId);
int result = this._usuarioRepository.Add(new Usuario
{
UserName = p_UsuarioDTO.UserName,
Password = Encriptador.Encriptar(p_UsuarioDTO.Password),
Perfil = entityPerfil
});
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public Usuario Single(string username, string password, int idEmpresa)
{
try
{
password = Encriptador.Encriptar(password);
var usuario = repository.GetByCredenciales(username, password, idEmpresa);
usuario.Empleado = EmpleadoBL.Instancia.Single(usuario.IdEmpleado);
usuario.Rol = RolBL.Instancia.Single(usuario.IdRol);
usuario.Empleado.Persona = PersonaBL.Instancia.Single(usuario.IdEmpleado);
usuario.Empleado.Cargo = CargoBL.Instancia.Single(usuario.IdCargo);
return(usuario);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void recalcular <T>(AbstractBll <T> bll) where T : IBusinessEntity
{
IList <T> elementos = bll.BuscarTodos();
String hash = "";
foreach (T e in elementos)
{
hash += ((IVerificable)e).GenerarVerificacion();
}
Dictionary <string, object> propiedades = new Dictionary <string, object>();
propiedades.Add("entidad", typeof(T).Name);
Verificacion verificacion = base.BuscarTodos(propiedades)[0];
verificacion.Hash = Encriptador.Encriptar(hash);
dal.Modificar(verificacion);
}
public async Task <IHttpActionResult> GetByCredentials(string codigo, string password)
{
string _encriptedPassword = _Encriptador.Encriptar(password, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
tblUsuario tblUsuario = await db.tblUsuario.FirstOrDefaultAsync(x => x.Email == codigo && x.ClaveUsuario == _encriptedPassword);
if (tblUsuario == null)
{
return(NotFound());
}
UsuarioModel data = new UsuarioModel
{
Email = tblUsuario.Email,
Id = tblUsuario.IdUsuario,
Nombre = tblUsuario.Nombre,
};
return(Ok(data));
}
public ActionResult EditUsuario(UsuarioViewModel model)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
{
return(RedirectToAction("Index", "Home"));
}
if (!ModelState.IsValid)
{
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
return(View(model));
}
using (SeguricelEntities db = new SeguricelEntities())
{
Encriptador Encrypt = new Encriptador();
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
string encryptedPassword = Encrypt.Encriptar(model.PasswordUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
Usuario usuario = (from d in db.Usuario
where d.IdUsuario == model.Id
select d).FirstOrDefault();
usuario.ClaveUsuario = encryptedPassword;
usuario.CodigoUsuario = model.EmailUsuario;
usuario.Email = model.EmailUsuario;
usuario.IdTipoUsuario = model.IdTipoUsuario;
usuario.PrimeraVez = true;
usuario.Nombre = model.Nombre;
db.SaveChanges();
ClasesVarias.AddBitacoraUsuario(db,
"Usuario para " + model.Nombre,
105000001,
"Actualizar");
}
return(RedirectToAction("Usuarios"));
}
public String verificarIntegridad()
{
String hash = "";
UsuarioBll usuarioBll = new UsuarioBll();
foreach (Usuario u in usuarioBll.BuscarTodos())
{
if (!u.verificacion.Equals(u.GenerarVerificacion()))
{
return("La verificacion del usuario con ID " + u.Id + " no ha sido satisfactoria. Se necesita restaurar el sistema.");
}
hash += u.verificacion;
}
Verificacion verificacion = dal.BuscarPorId(1);
if (!verificacion.Hash.Equals(Encriptador.Encriptar(hash)))
{
return("La verificacion no ha sido satisfactoria. Algun registro ha sido agregado o eliminado de la tabla Usuario");
}
return("Verificacion exitosa");
}
public static void EnviarEmailConfirmPassword(string Email, ControllerContext _context, RouteCollection routeCollection,
string esquema, string HostName)
{
string Text = string.Empty;
string Html = string.Empty;
Encriptador _Encriptar = new Encriptador();
using (Entities db = new Entities())
{
tblUsuario Usuario = db.tblUsuario.Where(x => x.Email == Email).FirstOrDefault();
string _encriptedId = _Encriptar.Encriptar(Usuario.IdUsuario.ToString(), Encriptador.HasAlgorimt.SHA1
, Encriptador.Keysize.KS256);
var routeValues = new RouteValueDictionary();
routeValues.Add("eui", _encriptedId);
string _RecoverPasswordPage = UrlHelper.GenerateUrl(null, "RecoveryPage", "Account", esquema, HostName,
String.Empty, routeValues, routeCollection, _context.RequestContext, false);
Text = string.Format(Resources.ForgotPasswordResource.ContenidoEmailTexto, Environment.NewLine, _RecoverPasswordPage
, Usuario.Nombre);
Html = string.Format(Resources.ForgotPasswordResource.ContenidoEmailHTML
, Resources.ForgotPasswordResource.HeaderString
, _RecoverPasswordPage
, Usuario.Nombre
, Resources.BCMWebPublic.labelAppSlogan
, Resources.ForgotPasswordResource.RecuperarHeaderString);
}
string UserID = string.Empty;
string Password = string.Empty;
string SMTPPort = string.Empty;
string Host = string.Empty;
string From = string.Empty;
AppSettings(out UserID, out Password, out SMTPPort, out Host, out From);
SendEmail(From, Resources.ForgotPasswordResource.HeaderString, Html, Text, Email, UserID, Password, SMTPPort, Host, true);
}
public void UsuarioModificacion(Usuario usuario)
{
try
{
Encriptador encriptador = new Encriptador();
Datos datos = new Datos();
datos.ConfigurarConexion();
datos.StoreProcedure("SP_ActualizarUsuario");
datos.AgregarParametro("@IDUsuario", usuario.ID_Usuario);
datos.AgregarParametro("@Email", usuario.Email);
datos.AgregarParametro("@Password", encriptador.Encriptar(usuario.Password));
datos.AgregarParametro("@Nombres", usuario.Nombres);
datos.AgregarParametro("@Apellidos", usuario.Apellidos);
datos.AgregarParametro("@DNI", usuario.DNI);
datos.AgregarParametro("@IDProvincia", IDProvincia(usuario.Domicilio.Provincia));
datos.AgregarParametro("@Ciudad", usuario.Domicilio.Ciudad);
datos.AgregarParametro("@Calle", usuario.Domicilio.Calle);
datos.AgregarParametro("@Numero", usuario.Domicilio.Numero);
datos.AgregarParametro("@Piso", usuario.Domicilio.Piso);
datos.AgregarParametro("@CP", usuario.Domicilio.CodigoPostal);
datos.AgregarParametro("@Departamento", usuario.Domicilio.Departamento);
datos.AgregarParametro("@Referencia", usuario.Domicilio.Referencia);
datos.AgregarParametro("@IDTipo", usuario.TipoUsuario.ID_Tipo);
datos.AgregarParametro("@Telefono", usuario.Telefono);
datos.AgregarParametro("@Activo", usuario.Activo);
datos.ConectarDB();
datos.Ejecutar();
}
catch (Exception ex)
{
throw ex;
}
finally
{
Datos datos = new Datos();
datos.ConfigurarConexion();
datos.DesconectarDB();
}
}
public ActionResult CreateUsuario(UsuarioViewModel model)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
return RedirectToAction("Index", "Home");
if (!ModelState.IsValid)
{
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
return View(model);
}
using (SeguricelEntities db = new SeguricelEntities())
{
Encriptador Encrypt = new Encriptador();
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
string encryptedPassword = Encrypt.Encriptar(model.PasswordUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
Usuario usuario = new Usuario
{
ClaveUsuario = encryptedPassword,
Email = model.EmailUsuario,
CodigoUsuario = string.Empty,
FechaCambioEstatus = DateTime.UtcNow,
FechaUltimaConexion = DateTime.UtcNow,
IdEstadoUsuario = (int)eEstadoUsuario.Activo,
IdTipoUsuario = model.IdTipoUsuario,
IdUsuario = Guid.NewGuid(),
Nombre = model.Nombre,
Pregunta1 = string.Empty,
Pregunta2 = string.Empty,
Pregunta3 = string.Empty,
PrimeraVez = true,
Respuesta1 = string.Empty,
Respuesta2 = string.Empty,
Respuesta3 = string.Empty
};
db.Usuario.Add(usuario);
db.SaveChanges();
ClasesVarias.AddBitacoraUsuario(db,
"Usuario para " + model.Nombre,
105000001,
"Agregar");
}
return RedirectToAction("Usuarios");
}
public ActionResult Checklogin(LoginViewModel model, string returnUrl)
{
ViewBag.Title = Resources.LoginResource.PageTitle;
if (!ModelState.IsValid)
{
return View(model);
}
// No cuenta los errores de inicio de sesión para el bloqueo de la cuenta
// Para permitir que los errores de contraseña desencadenen el bloqueo de la cuenta, cambie a shouldLockout: true
//var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
Encriptador Encrypt = new Encriptador();
using (SeguricelEntities db = new SeguricelEntities())
{
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
string encryptedPassword = Encrypt.Encriptar(model.Password, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
Usuario dataUsuario = (from u in db.Usuario
where (u.CodigoUsuario == model.Email | u.Email == model.Email) && u.ClaveUsuario == encryptedPassword
select u).FirstOrDefault();
if (dataUsuario != null)
{
switch ((eEstadoUsuario)dataUsuario.IdEstadoUsuario)
{
case eEstadoUsuario.Conectado:
case eEstadoUsuario.Activo:
string[] utz = model.UserTimeZone.Split(':');
int hourZone;
int minZone;
if (utz.Length <= 0)
{
hourZone = 0;
minZone = 0;
}
else
{
hourZone = int.Parse(utz[0]);
minZone = int.Parse(utz[1]);
}
CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel()
{
Email = dataUsuario.Email,
Estado = (eEstadoUsuario)dataUsuario.IdEstadoUsuario,
Id = dataUsuario.IdUsuario,
FechaUltimaConexion = DateTime.UtcNow,
Name = dataUsuario.Nombre,
IdTipoUsuario = dataUsuario.IdTipoUsuario,
HoursTimeZone = hourZone,
MinutesTimeZone = minZone,
Culture = Request.UserLanguages[0],
DefaultCulture = "es-VE"
};
string _jsonUserData = JsonConvert.SerializeObject(serializeModel);
FormsAuthenticationTicket authTicket =
new FormsAuthenticationTicket(1, serializeModel.Email,
DateTime.UtcNow.AddHours(-4).AddMinutes(-30),
DateTime.UtcNow.AddHours(-4).AddMinutes(-15),
false, _jsonUserData);
string encTicket = FormsAuthentication.Encrypt(authTicket);
HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
bool PrimeraVez = false;
/*if (dataUsuario.FechaUltimaConexion == null)
PrimeraVez = true;*/
PrimeraVez = dataUsuario.PrimeraVez;
Response.Cookies.Add(faCookie);
Session["user"] = encTicket;
if (PrimeraVez)
return RedirectToAction("Perfil", "Account");
else
{
return ConectarUsuario(dataUsuario, db);
}
case eEstadoUsuario.Inactivo:
ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessageInactivo);
break;
case eEstadoUsuario.Bloqueado:
ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessageBloqueado);
break;
default:
ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessage);
break;
}
}
else
{
ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessage);
}
}
return View(model);
}
public ActionResult EditUsuario(Guid id)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
return RedirectToAction("Index", "Home");
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
UsuarioViewModel model = new UsuarioViewModel();
using (SeguricelEntities db = new SeguricelEntities())
{
Encriptador Encrypt = new Encriptador();
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
Usuario usuario = (from d in db.Usuario
where d.IdUsuario == id
select d).FirstOrDefault();
string decryptedPassword = Encrypt.Encriptar(usuario.ClaveUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
if (usuario != null)
{
model.ConfirmPasswordUsuario = decryptedPassword;
model.EmailUsuario = usuario.Email;
model.Estado = usuario.IdEstadoUsuario;
model.Id = usuario.IdUsuario;
model.IdTipoUsuario = usuario.IdTipoUsuario;
model.Nombre = usuario.Nombre;
model.PasswordUsuario = decryptedPassword;
}
}
return View(model);
}
public ActionResult EditUsuario(UsuarioViewModel model)
{
if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
return RedirectToAction("Index", "Home");
if (!ModelState.IsValid)
{
ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
return View(model);
}
using (SeguricelEntities db = new SeguricelEntities())
{
Encriptador Encrypt = new Encriptador();
Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
string encryptedPassword = Encrypt.Encriptar(model.PasswordUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
Usuario usuario = (from d in db.Usuario
where d.IdUsuario == model.Id
select d).FirstOrDefault();
usuario.ClaveUsuario = encryptedPassword;
usuario.CodigoUsuario = model.EmailUsuario;
usuario.Email = model.EmailUsuario;
usuario.IdTipoUsuario = model.IdTipoUsuario;
usuario.PrimeraVez = true;
usuario.Nombre = model.Nombre;
db.SaveChanges();
ClasesVarias.AddBitacoraUsuario(db,
"Usuario para " + model.Nombre,
105000001,
"Actualizar");
}
return RedirectToAction("Usuarios");
}
