private void LoginRemoto()
{
using (var proxy = new ProxySeguridad())
{
var cryptocon = new SimpleInteroperableEncryption();
var respuesta = proxy.Login(new RequestLogin
{
AcronimoAplicacion = ConfigurationManager.AppSettings["AcronimoAplicacion"],
CodigoUsuario = txtUser.Text,
Clave = cryptocon.Encrypt(txtPass.Text),
Dominio = cboDominio.EditValue.ToString(),
});
if (!respuesta.Resultado.Success)
{
throw new SecurityException(respuesta.Resultado.Message);
}
InfoUsuario.Initialize();
InfoUsuario.Instancia.IdPerfilUsuario = respuesta.IdPerfilUsuario;
var response = proxy.GetInfoUsuario(new RequestInfoUsuario
{
IdPerfilUsuario = InfoUsuario.Instancia.IdPerfilUsuario
});
InfoUsuario.Instancia.NombresCompletos = response.NombresCompletos;
InfoUsuario.Instancia.CorreoUsuario = response.Correo;
InfoUsuario.Instancia.Dominio = response.Dominio;
InfoUsuario.Instancia.FechaUltimoIngreso = DateTime.Today;
}
}
public bool CambiarContrasenia(RequestCambioClave request)
{
bool done = false;
SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);
//ENCRIPTAMOS LAS CONTRASEÑAS
request.ClaveAntigua = crypter.Encrypt(request.ClaveAntigua);
request.ClaveNueva = crypter.Encrypt(request.ClaveNueva);
request.ClaveNuevaConfirmada = crypter.Encrypt(request.ClaveNuevaConfirmada);
request.Dominio = WebConfigReader.DominioAplicacion;
request.Acronimo = WebConfigReader.AcronimoAplicacion;
request.TipoCambioClave = TipoCambioClave.Ui;
ResponseCambioClave response = (new SeguridadProxyRest()).CambiarClaveWeb(request);
if (response.Result.Satisfactorio == false)
{
throw new Exception(response.Result.Mensaje);
}
done = true;
return(done);
}
public bool ResetarContrasenia(RequestCambioClave request)
{
bool done = false;
SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);
string contraseniaGenerada = Helper.GenerarContrasenia();
request.ClaveAntigua = request.ClaveNuevaConfirmada = request.ClaveNueva = crypter.Encrypt(contraseniaGenerada);
request.Dominio = WebConfigReader.DominioAplicacion;
request.Acronimo = WebConfigReader.AcronimoAplicacion;
request.TipoCambioClave = TipoCambioClave.Sys;
ResponseCambioClave response = (new SeguridadProxyRest()).CambiarClaveWeb(request);
if (response.Result.Satisfactorio == false)
{
throw new Exception(response.Result.Mensaje);
}
this.NotificarCambioConstraseniaMSC(response.CodigoUsuario, response.Correo, response.Nombres, contraseniaGenerada);
done = true;
return(done);
}
public bool CambiarConstraseniaMSC(RequestCambioClave request)
{
bool done = false;
Result result = this.ValidacionCambiarConstraseniaMSC(request);
if (result.Satisfactorio == false)
{
throw new Exception(result.Mensaje);
}
SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);
string contraseniaGenerada = string.Empty;
if (request.TipoCambioClave == TipoCambioClave.Sys)
{
contraseniaGenerada = Helper.GenerarContrasenia();
request.ClaveAntigua = request.ClaveNuevaConfirmada = request.ClaveNueva = crypter.Encrypt(contraseniaGenerada);
}
else
{
//ENCRIPTAMOS LAS CONTRASEÑAS
request.ClaveAntigua = crypter.Encrypt(request.ClaveAntigua);
request.ClaveNueva = crypter.Encrypt(request.ClaveNueva);
request.ClaveNuevaConfirmada = crypter.Encrypt(request.ClaveNuevaConfirmada);
}
request.Dominio = WebConfigReader.DominioAplicacion;
request.Acronimo = WebConfigReader.AcronimoAplicacion;
ResponseCambioClave response = (new SeguridadProxyRest()).CambiarClaveWeb(request);
if (response.Result.Satisfactorio == false)
{
throw new Exception(response.Result.Mensaje);
}
//ENVIAMOS EL CORREO
if (request.TipoCambioClave == TipoCambioClave.Sys)
{
this.NotificarCambioConstraseniaMSC(response.CodigoUsuario, response.Correo, response.Nombres, contraseniaGenerada);
}
done = true;
return(done);
}
private void btnEncriptar_Click(object sender, EventArgs e)
{
try
{
var crypto = new SimpleInteroperableEncryption();
var resultado = crypto.Encrypt(txtClave.Text);
Clipboard.SetText(resultado);
lblResultado.Text = string.Format("Resultado: {0}", resultado);
MessageBox.Show("Texto copiado al portapapeles", Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
//public GenerarClaveUsuarioResponseDTO ResetearContrasenia(GenerarClaveUsuarioRequestDTO request)
//{
// GenerarClaveUsuarioResponseDTO response = new GenerarClaveUsuarioResponseDTO();
// ResponseCambioClaveDTO responseProxy = new ResponseCambioClaveDTO();
// SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.Encriptacion.SemillaEncriptacionPublica);
// RequestCambioClaveDTO requestDTO = new RequestCambioClaveDTO();
// string contraseniaGenerada = HelperSeguridad.GenerarContrasenia();
// requestDTO.ClaveAntigua = requestDTO.ClaveNuevaConfirmada = requestDTO.ClaveNueva = crypter.Encrypt(contraseniaGenerada);
// requestDTO.Dominio = request.DominioAplicacion;
// requestDTO.Acronimo = request.AcronimoAplicacion;
// requestDTO.TipoCambioClave = TipoCambioClave.Sys;
// requestDTO.CodigoUsuario = request.Usuario.Trim();
// responseProxy = (new SeguridadProxy()).CambiarClaveWeb(requestDTO);
// int codigoError = 0;
// if (responseProxy.Result.Satisfactorio == false)
// if (int.TryParse(responseProxy.Result.CodigoError, out codigoError) && codigoError < 0)
// {
// throw new ResultException { Result = responseProxy.Result };
// }
// else if (!int.TryParse(responseProxy.Result.CodigoError, out codigoError) && codigoError == 0)
// {
// throw new ResultException { Result = responseProxy.Result };
// }
// else
// {
// throw new Exception(responseProxy.Result.Mensaje);
// }
// this.NotificarCambioConstraseniaMSC(responseProxy.CodigoUsuario, responseProxy.Correo, responseProxy.Nombres, contraseniaGenerada);
// return response;
//}
//public void NotificarCambioConstraseniaMSC(string CodigoUsuario, string Correo, string Nombres, string contraseniaGenerada)
//{
// RequestNotificacionDTO requestNotificacion = new RequestNotificacionDTO();
// #region VALIDAMOS EL CORREO DEL CLIENTE
// if (string.IsNullOrEmpty(Correo))
// return;
// #endregion
// requestNotificacion.CodigoLinea = "HLL";
// requestNotificacion.CorreosPara.Add(Correo);
// requestNotificacion.CorreoDe = WebConfigReader.Mailer.From;
// requestNotificacion.CodigoNotificacion = (int)TipoNotificacion.NotificacionRecordarClave;
// requestNotificacion.CuerpoValores = new Dictionary<string, string>() {
// { "{Cliente}", Nombres },
// { "{Usuario}", CodigoUsuario },
// { "{Clave}", contraseniaGenerada },
// { "{urlpagina}", WebConfigReader.Aplicacion.UrlAplicacion.Trim() }
// };
// Task task = new Task((Action<Object>)EnviarCorreo, requestNotificacion);
// task.Start();
//}
//public void EnviarCorreo(Object requestNotificacion)
//{
// NotificacionBL notificacionBL = new NotificacionBL();
// notificacionBL.requestNotificationDTO = requestNotificacion as RequestNotificacionDTO;
// notificacionBL.EnviarNotificacionAsync();
//}
public CambiarClaveUsuarioResponseDTO CambiarClaveUsuario(CambiarClaveUsuarioRequestDTO request)
{
CambiarClaveUsuarioResponseDTO response = new CambiarClaveUsuarioResponseDTO();
ResponseCambioClaveDTO responseProxy = new ResponseCambioClaveDTO();
RequestCambioClaveDTO requestDTO = new RequestCambioClaveDTO();
SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.Encriptacion.SemillaEncriptacionPublica);
//string contraseniaGenerada = HelperSeguridad.GenerarContrasenia();
//ENCRIPTAMOS LAS CONTRASEÑAS
requestDTO.Dominio = request.DominioAplicacion;
requestDTO.Acronimo = request.AcronimoAplicacion;
requestDTO.TipoCambioClave = TipoCambioClave.Ui;
requestDTO.ClaveAntigua = request.ClaveAnterior; //crypter.Encrypt(request.ClaveAnterior);
requestDTO.ClaveNueva = requestDTO.ClaveNuevaConfirmada = request.ClaveNueva; //crypter.Encrypt(request.ClaveNueva);
requestDTO.CodigoUsuario = request.Usuario.Trim();
responseProxy = (new SeguridadProxy()).CambiarClaveWeb(requestDTO);
int codigoError = 0;
if (responseProxy.Result.Satisfactorio == false)
{
if (int.TryParse(responseProxy.Result.CodigoError, out codigoError) && codigoError < 0)
{
throw new ResultException {
Result = responseProxy.Result
};
}
else if (!int.TryParse(responseProxy.Result.CodigoError, out codigoError) && codigoError == 0)
{
throw new ResultException {
Result = responseProxy.Result
};
}
else
{
throw new Exception(responseProxy.Result.Mensaje);
}
}
return(response);
}
public byte[] cargarDatos(string dato)
{
var crypt = new SimpleInteroperableEncryption(ConfigurationManager.AppSettings["MetodoEncriptacion"].ToString());
var datoEncriptado = crypt.Encrypt(dato);
QRCoder.QRCodeGenerator qRCodeGenerator = new QRCoder.QRCodeGenerator();
QRCoder.QRCodeData qRCodeData = qRCodeGenerator.CreateQrCode(datoEncriptado, QRCoder.QRCodeGenerator.ECCLevel.Q);
QRCoder.QRCode qRCode = new QRCoder.QRCode(qRCodeData);
//transformamos en bits
Bitmap bmp = qRCode.GetGraphic(7);
using (MemoryStream ms = new MemoryStream())
{
//importante para generar el qr
bmp.Save(ms, ImageFormat.Bmp);
//row.CodigoQR = ms.ToArray();
return(ms.ToArray());
}
}
public ResponseLoginUsuario Login(RequestLogin request)
{
var crypt = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);
var dominio = WebConfigReader.DominioAplicacion;
request.AcronimoAplicacion = WebConfigReader.AcronimoAplicacion;
request.Clave = crypt.Encrypt(request.Clave);
//request.Dominio = dominio.ToUpper();
if (request.CodigoUsuario.IndexOf("\\") > -1)
{
request.Dominio = request.CodigoUsuario.Split('\\')[0].ToUpper();
request.CodigoUsuario = request.CodigoUsuario.Split('\\')[1];
}
else
{
request.Dominio = dominio.ToUpper();
}
return((new SeguridadProxyRest()).Login(request));
}
public ResponseCambiarClaveUsuario CambiarClaveUsuario(RequestCambiarClaveUsuarioViewModel request)
{
var response = new ResponseCambiarClaveUsuario();
try
{
SimpleInteroperableEncryption crypter = new SimpleInteroperableEncryption(WebConfigReader.SemillaEncriptacionPublica);
var requestAgente = new RequestCambiarClaveUsuario();
requestAgente.Usuario = request.Usuario;
requestAgente.ClaveAnterior = crypter.Encrypt(request.ClaveAnterior);
requestAgente.ClaveNueva = crypter.Encrypt(request.ClaveNueva);
requestAgente.AcronimoAplicacion = WebConfigReader.AcronimoAplicacion;
requestAgente.DominioAplicacion = WebConfigReader.DominioAplicacion;
response = new TransmisionesProxyrest().CambiarClaveUsuario(requestAgente);
}
catch (Exception ex)
{
response.Result = new Result {
Satisfactorio = false
};
ManejadorExcepciones.PublicarExcepcion(ex, PoliticaExcepcion.AgenteServicios);
}
return(response);
}
public async void EnvioCorreo(TipoCorreo tipoCorreo)
{
var Ruta = string.Empty;
var Cadena = new String[] {
string.Format("{0} {1} {2}", Nombres, ApellidoPaterno, ApellidoMaterno),
Codigo,
DateTime.Today.ToString("D"),
DateTime.Today.AddDays(90).ToString("D")
};
var Contenido = new ContenidoMail();
switch (tipoCorreo)
{
case TipoCorreo.UsuarioNuevoExterno:
Ruta = "ErickOrlando.Seguridad.Negocio.Editables.Usuarios.PlantillaCorreo.htm";
Contenido.Asunto = string.Format(Properties.Resources.msgAsuntoActivacion, this.Codigo);
break;
case TipoCorreo.UsuarioNuevoInterno:
Ruta = "ErickOrlando.Seguridad.Negocio.Editables.Usuarios.PlantillaCorreoUsuarioAD.htm";
Contenido.Asunto = string.Format(Properties.Resources.msgAsuntoActivacion, this.Codigo);
Cadena = new String[]
{
Nombres,
Codigo,
Dominio
};
break;
case TipoCorreo.CambioClave:
Ruta = "ErickOrlando.Seguridad.Negocio.Editables.Usuarios.PlantillaContrasena.htm";
Contenido.Asunto = string.Format(Properties.Resources.msgAsuntoRestablecimiento, this.Codigo);
break;
}
try
{
TextReader texto = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(Ruta));
#region Configuracion del Correo
var crypto = new SimpleInteroperableEncryption();
Contenido.RemitenteMail = ConfigurationManager.AppSettings["RemitenteEmail"];
Contenido.RemitenteNombre = ConfigurationManager.AppSettings["RemitenteNombre"];
Contenido.Servidor = ConfigurationManager.AppSettings["SMTPServer"];
Contenido.Puerto = int.Parse(ConfigurationManager.AppSettings["PuertoSMTP"]);
Contenido.Credenciales = new System.Net.NetworkCredential(
crypto.Decrypt(ConfigurationManager.AppSettings["CredencialUser"]),
crypto.Decrypt(ConfigurationManager.AppSettings["CredencialPass"]));
Contenido.UsarSSL = true;
Contenido.CuerpoMensaje = texto.ReadToEnd();
Contenido.ListaDestinatarios.Add(Correo);
Contenido.ArrayValores = Cadena;
Contenido.Html = true;
texto.Close();
#endregion
#region Contenido del Correo
using (MailMessage mail = new MailMessage())
{
mail.From = new MailAddress(Contenido.RemitenteMail, Contenido.RemitenteNombre);
foreach (var Destinatario in Contenido.ListaDestinatarios)
{
mail.To.Add(Destinatario);
}
foreach (var Destinatario in Contenido.ListaDestinatariosCC)
{
mail.CC.Add(Destinatario);
}
foreach (var Destinatario in Contenido.ListaDestinatariosBCC)
{
mail.Bcc.Add(Destinatario);
}
var CuerpoHTML = new StringBuilder();
if (Contenido.ArrayValores.Length > 0)
{
CuerpoHTML.AppendFormat(Contenido.CuerpoMensaje, Contenido.ArrayValores);
}
else
{
CuerpoHTML.Append(Contenido.CuerpoMensaje);
}
CuerpoHTML.AppendLine();
CuerpoHTML.AppendLine();
CuerpoHTML.AppendLine();
CuerpoHTML.Append(Contenido.Html ? Contenido.PieDeCorreoHTML : Contenido.PieDeCorreo);
mail.Subject = Contenido.Asunto;
mail.Body = CuerpoHTML.ToString();
mail.IsBodyHtml = Contenido.Html;
//Limpiamos el StringBuilder
CuerpoHTML.Length = 0;
var smtp = new SmtpClient();
smtp.Host = Contenido.Servidor;
if (Contenido.Puerto.HasValue)
{
smtp.Port = Contenido.Puerto.Value;
}
if (Contenido.Credenciales != null)
{
smtp.Credentials = Contenido.Credenciales;
}
else
{
smtp.UseDefaultCredentials = true;
}
if (Contenido.Servidor.ToLower() == "localhost" || Contenido.Servidor == "127.0.0.1")
{
smtp.DeliveryMethod = SmtpDeliveryMethod.PickupDirectoryFromIis;
}
if (!string.IsNullOrEmpty(Contenido.DirectorioRecojoIIS))
{
smtp.PickupDirectoryLocation = Contenido.DirectorioRecojoIIS;
}
smtp.EnableSsl = Contenido.UsarSSL;
//await smtp.SendMailAsync(mail);
await smtp.SendMailAsync(mail);
}
#endregion
}
catch (SmtpException ex)
{
var msg = string.Format("{0}\n{1}",
ex.Message, ex.InnerException == null ? string.Empty : ex.InnerException.Message);
System.Diagnostics.Trace.WriteLine(msg);
}
}
/// <summary>
/// Cambia la contraseña de un usuario externo, si el campo es vacio se crea una contraseña, de lo contrario registra al constraseña enviada.
/// </summary>
/// <param name="request">Constraseña a registrar</param>
/// <returns>Contraseña generada</returns>
public static ResponseCambioClave CambiarClaveWeb(RequestCambioClave request)
{
ResponseCambioClave response = new ResponseCambioClave();
var publicCrypter = new SimpleInteroperableEncryption();
var info = GetInfoBasicaUsuariosByCodigo(new RequestInfoBasicaUsuarioDTO
{
CodigoUsuario = request.CodigoUsuario,
Dominio = request.Dominio
});
if (!info.Resultado.Success)
{
throw new InvalidOperationException("El usuario no existe!");
}
if (info.InfoBasica.Tipo != "E")
{
throw new InvalidOperationException("Sólo los usuarios externos pueden cambiar su contraseña");
}
//SI SE HA SOLICITADO CONTRASEÑA, SE VALIDA LA CONTRASEÑA ANTIGUA
if (request.TipoCambioClave == TipoCambioClave.Ui)
{
// Comprobamos si el campo de Respuesta Secreta se encuentra lleno para validar
// que el usuario se olvidó se contraseña y posteriormente hacer el cambio.
if (string.IsNullOrEmpty(request.RespuestaSecreta))
{
ResponseLoginUsuario responseLogin = Login(new RequestLogin
{
CodigoUsuario = request.CodigoUsuario,
Clave = publicCrypter.Decrypt(request.ClaveAntigua),
Dominio = request.Dominio,
AcronimoAplicacion = request.Acronimo
});
if (!responseLogin.Resultado.Success)
{
throw new Exception("La contraseña es incorrecta.");
}
}
else
{
// Comprobamos que la respuesta a la pregunta Secreta sea válida.
using (var ctx = new SeguridadEntities())
{
var clave = (from clav in ctx.Claves
where clav.IdUsuario == info.InfoBasica.IdUsuario &&
clav.Ultimo
select new { RespuestaSecreta = clav.Respuesta }).FirstOrDefault();
if (clave != null)
{
if (clave.RespuestaSecreta != GRCrypto.Encriptar(request.RespuestaSecreta))
{
throw new SecurityException("La respuesta secreta no coincide!");
}
}
}
}
}
// En caso sea un reseteo de clave
if (request.TipoCambioClave == TipoCambioClave.Sys)
{
request.ClaveAntigua = request.ClaveNuevaConfirmada = request.ClaveNueva = publicCrypter.Decrypt(request.ClaveNueva);
}
else
{
//DESENCRIPTAR LA CONTRASENIA
request.ClaveAntigua = publicCrypter.Decrypt(request.ClaveAntigua);
request.ClaveNueva = publicCrypter.Decrypt(request.ClaveNueva);
request.ClaveNuevaConfirmada = publicCrypter.Decrypt(request.ClaveNuevaConfirmada);
}
Result result = ValidacionCambiarClaveWeb(request);
if (result.Success == false)
{
throw new Exception(result.Message);
}
bool primeraClave = false;
try
{
//Validamos si tiene Clave registrada.
GRPrincipal.Load(request.CodigoUsuario, request.Dominio);
}
catch (DataPortalException ex)
{
if (ex.BusinessException != null)
{
if (ex.BusinessException.GetType() == typeof(UsuarioSinClaveException))
{ //SI LA EXCEPCION ES USUARIOSINCLAVE SE LE CREA UNA CLAVE
ActivarUsuario activarUsuario = ActivarUsuario.GetActivarUsuario(new FiltroUsuarios
{
Usuario = request.CodigoUsuario, Dominio = request.Dominio
});
activarUsuario.PreguntaSecreta = activarUsuario.RespuestaSecreta = request.CodigoUsuario;
activarUsuario.ClaveSecreta = activarUsuario.ConfirmarClave = request.ClaveNueva;
activarUsuario.Save();
primeraClave = true;
}
}
}
if (!primeraClave)
{
var cambiarClave = CambiarClave.GetCambiarClave(new FiltroUsuarios
{
Usuario = request.CodigoUsuario, Dominio = request.Dominio
});
cambiarClave.ClaveNueva = cambiarClave.ConfirmarClave = request.ClaveNueva;
cambiarClave.RespuestaSecreta = string.IsNullOrEmpty(request.RespuestaSecreta)
? cambiarClave.SecretAnswer : request.RespuestaSecreta;
CambiarClave.ByPassClave = true;
cambiarClave.Save();
}
response.Correo = info.InfoBasica.Correo;
response.Nombres = info.InfoBasica.NombresCompletos;
response.CodigoUsuario = request.CodigoUsuario;
return(response);
}
public static ResponseUsuarioInsert InsertUsuario(RequestDTOUsuarioInsert request)
{
ResponseUsuarioInsert result = new ResponseUsuarioInsert();
var perfil = ErickOrlando.Seguridad.Negocio.Editables.PerfilUsuario.NewPerfilUsuario();
var usuario = Usuario.NewUsuario();
try
{
if (String.IsNullOrEmpty(request.Codigo))
{
return(result);
}
string IdAplicacion = string.Empty;
string IdEmpresa = string.Empty;
string IdEmpresaPertenencia = string.Empty;
string IdRol = string.Empty;
string IdCargo = string.Empty;
using (var ctx = new SeguridadEntities())
{
// Buscamos el ID de la Aplicacion.
IdAplicacion = (from app in ctx.Aplicaciones
where app.Acronimo == request.Acronimo
select app.IdAplicacion).SingleOrDefault();
if (string.IsNullOrEmpty(IdAplicacion))
{
throw new ApplicationException(string.Format("La Aplicación {0} no existe!", request.Acronimo));
}
// Buscamos el ID de la Empresa.
IdEmpresa = (from emp in ctx.Empresas
where emp.RUC == request.RUCEmpresa
select emp.IdEmpresa).SingleOrDefault();
if (string.IsNullOrEmpty(IdEmpresa))
{
throw new ApplicationException(string.Format("La Empresa con el RUC {0} no existe!", request.RUCEmpresa));
}
if (request.RUCEmpresa != request.RUCEmpresaPertenencia)
{
// Buscamos el ID de la Empresa Pertenencia.
IdEmpresaPertenencia = (from emp in ctx.Empresas
where emp.RUC == request.RUCEmpresaPertenencia
select emp.IdEmpresa).SingleOrDefault();
if (string.IsNullOrEmpty(IdEmpresaPertenencia))
{
throw new ApplicationException(string.Format("La Empresa con el RUC {0} no existe!", request.RUCEmpresaPertenencia));
}
}
else
{
IdEmpresaPertenencia = IdEmpresa;
}
// Buscamos el ID del Rol.
IdRol = (from roles in ctx.Roles
where roles.IdAplicacion == IdAplicacion &&
roles.NombreRol == request.Rol
select roles.IdRol).SingleOrDefault();
if (string.IsNullOrEmpty(IdRol))
{
throw new ApplicationException(string.Format("No se encuentra el Rol {0}", request.Rol));
}
// Buscamos el ID del Cargo.
IdCargo = (from cargo in ctx.Cargo
where cargo.Descripcion == request.Cargo
select cargo.IdCargo).SingleOrDefault();
if (string.IsNullOrEmpty(IdCargo))
{
throw new ApplicationException(string.Format("No se encuentra el cargo {0}", request.Cargo));
}
ctx.Database.Connection.Close();
}
//Creacion de nuevo usuario
usuario.IdEmpresa = IdEmpresa;
usuario.IdEmpresaPertenencia = IdEmpresaPertenencia;
usuario.IdCargo = IdCargo;
usuario.Nombres = request.Nombres;
usuario.Alias = request.Alias;
usuario.Dominio = request.Dominio;
usuario.ApellidoMaterno = request.ApellidoMaterno;
usuario.ApellidoPaterno = request.ApellidoPaterno;
usuario.Codigo = request.Codigo;
usuario.Correo = request.Correo;
usuario.DNI = request.DNI;
usuario.Estado = true;
usuario.NotificarConCorreo = request.NotificacionConCorreo;
usuario.Tipo = request.Tipo;
usuario = usuario.Save();
//Recuperando usuario creado
var usuarioCreado = usuario;
//Estableciendo variables de entorno
Csla.ApplicationContext.GlobalContext["Placa"] = Environment.MachineName;
Csla.ApplicationContext.GlobalContext["Usuario"] = Environment.UserName;
//Creacion de perfil
perfil.IdAplicacion = IdAplicacion;
perfil.IdUsuario = usuarioCreado.Id;
perfil.Usuario = usuarioCreado.Nombres;
perfil.Aplicacion = IdAplicacion;
perfil.Caduca = request.Caduca;
perfil.VigenciaInicio = DateTime.Now;
perfil.VigenciaFin = DateTime.Now.AddYears(1);
//Asignando rol
var rolPerfil = perfil.RolesPerfiles.AddNew();
rolPerfil.IdRol = IdRol;
rolPerfil.IdAplicacion = IdAplicacion;
//Agregando permisos
rolPerfil.AgregarPermisos();
//Estableciendo recursos
var recursosList = RecursosInfoList.GetRecursosInfoList();
if (request.ListaRecursos != null)
{
foreach (var recurso in request.ListaRecursos)
{
string recursoact = recurso.Substring(0, recurso.IndexOf(":")).Trim();
string[] recursodetalle = recurso.Substring(recurso.IndexOf(":") + 1).Trim().Split(',');
foreach (var itemrecurso in recursosList.Where(x => x.Descripcion == recursoact))
{
var recursodetalles = from p in itemrecurso.Detalles
where recursodetalle.Contains(p.Descripcion)
select p;
foreach (var itemrecursodetalle in recursodetalles)
{
var recursoitem = perfil.Recursos.AddNew();
recursoitem.Conceder = true;
recursoitem.IdRecursoDetalle = itemrecursodetalle.ID;
perfil.Recursos.Add(recursoitem);
}
}
}
}
perfil.Save();
string Clave = string.Empty;
if (usuario.Tipo == "E")
{
//Creacion de contraseña
if (String.IsNullOrEmpty(request.Clave))
{
Clave = GenerarClaveAleatoria();
}
else
{
var crypto = new SimpleInteroperableEncryption();
Clave = crypto.Decrypt(request.Clave);
}
//Hay que intentar el Login para identificar si se debe crear la contraseña.
try
{
Csla.ApplicationContext.GlobalContext["Acronimo"] = request.Acronimo;
GRPrincipal.Load(usuario.Codigo, usuario.Dominio);
//GRPrincipal.Login(usuario.Codigo, GRCrypto.Encriptar( "clave"));
}
catch (DataPortalException ex)
{
if (ex.BusinessException.GetType() == typeof(UsuarioNoActivoException) ||
ex.BusinessException.GetType() == typeof(UsuarioSinClaveException))
{
var activacion = ActivarUsuario.GetActivarUsuario(new FiltroUsuarios
{
Usuario = usuario.Codigo,
Dominio = usuario.Dominio
});
activacion.NombreUsuario = request.Codigo;
activacion.PreguntaSecreta = request.PreguntaSecreta;
activacion.RespuestaSecreta = request.RespuestaSecreta;
activacion.ClaveSecreta = Clave;
activacion.ConfirmarClave = Clave;
try
{
activacion.Save();
}
catch (ValidationException)
{
throw new InvalidOperationException(activacion.BrokenRulesCollection.ToString());
}
}
}
}
result.IdUsuario = usuarioCreado.Id;
result.Clave = (string.IsNullOrEmpty(request.Clave)) ? Clave : string.Empty;
result.Codigo = request.Codigo;
result.Alias = request.Alias;
result.Resultado.Success = true;
result.Resultado.Message = string.Empty;
}
catch (ValidationException)
{
var msg1 = usuario.BrokenRulesCollection.ToString();
var msg2 = perfil.BrokenRulesCollection.ToString();
if (string.IsNullOrEmpty(msg1))
{
result.Resultado.Message = msg2;
}
else if (string.IsNullOrEmpty(msg2))
{
result.Resultado.Message = msg1;
}
else
{
result.Resultado.Message = string.Format("{0} {1}", msg1, msg2);
}
}
catch (DataPortalException ex)
{
result.Resultado.Message = ex.BusinessException.Message;
if (ex.BusinessException.InnerException != null)
{
result.Resultado.Messages.Add(new Result {
Message = ex.BusinessException.InnerException.Message
});
}
}
catch (Exception ex)
{
var msg = ex.Message;
if (ex.InnerException != null)
{
msg = ex.InnerException.Message;
}
result.Resultado.Message = msg;
}
return(result);
}
public static ResponseLoginUsuario Login(RequestLogin request)
{
var response = new ResponseLoginUsuario();
try
{
if (string.IsNullOrEmpty(request.Clave) || string.IsNullOrEmpty(request.CodigoUsuario))
{
throw new InvalidOperationException("El usuario y clave son obligatorios.");
}
if (string.IsNullOrEmpty(request.AcronimoAplicacion))
{
throw new InvalidOperationException("El acrónimo es obligatorio.");
}
// Desencriptamos el mensaje recibido.
var cryptocon = new SimpleInteroperableEncryption();
request.Clave = cryptocon.Decrypt(request.Clave);
//Comprobamos que el Nombre de Usuario contiene un Dominio
var infoUser = new UserDomain {
Usuario = request.CodigoUsuario, Dominio = request.Dominio
};
//Guardamos en el GlobalContext el valor que se reciba del Acrónimo
Csla.ApplicationContext.GlobalContext["Acronimo"] = request.AcronimoAplicacion;
if (string.IsNullOrEmpty(request.Dominio))
{
throw new InvalidOperationException("El dominio es obligatorio.");
}
var result = false;
//Comprobamos primero el tipo de Usuario
if (GRPrincipal.Load(infoUser.Usuario, infoUser.Dominio))
{
InfoUsuario.Initialize();
if (InfoUsuario.Instancia.Tipo) // Si es interno
{
result = GRPrincipal.Login(infoUser.Usuario, request.Clave, request.Dominio);
}
else // Si es externo
{
result = GRPrincipal.Login(infoUser.Usuario, GRCrypto.Encriptar(request.Clave));
}
}
else
{
throw new InvalidOperationException("El usuario no está inscrito para este Sistema");
}
if (!result)
{
throw new SecurityException("El usuario o clave no son válidos!");
}
response.Resultado.Success = result;
response.IdPerfilUsuario = InfoUsuario.Instancia.IdPerfilUsuario;
}
catch (DataPortalException ex)
{
response.Resultado.Message = ex.BusinessException.Message;
}
catch (Exception ex)
{
var msg = ex.Message;
if (ex.InnerException != null)
{
msg = ex.InnerException.Message;
}
response.Resultado.Message = msg;
}
return(response);
}