/// <summary>
/// Metodo que sirve para Obtener la lista de tipo Producto
/// </summary>
/// <param name="pProducto">Filtro de tipo Producto</param>
/// <returns></returns>
public RespuestaProducto ObtenerProducto(Producto pProducto)
{
var respuesta = new RespuestaProducto();
try
{
var respObtenerProducto = dal.ObtenerProducto(pProducto);
respuesta.Producto = respObtenerProducto.ListaProducto != null || respObtenerProducto.ListaProducto.Count > 0 ?
respObtenerProducto.ListaProducto.FirstOrDefault() : null;
return(respuesta.Producto != null ?
new RespuestaProducto {
Respuesta = new Respuesta(string.Empty, Respuesta.CodExitoso), Producto = respuesta.Producto
} :
new RespuestaProducto {
Respuesta = new Respuesta(Respuestas.GI03, Respuesta.CodExitoso), Producto = new Producto()
});
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pProducto);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaProducto {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo que sirve para Eliminar o Desactivar un objeto de tipo Proveedor
/// </summary>
/// <param name="pProveedor"></param>
/// <returns></returns>
public RespuestaProveedor EliminarProveedor(Proveedor pProveedor)
{
var respuesta = new RespuestaProveedor();
try
{
//CONSULTA A ACCESO A DATOS
respuesta = dal.EliminarProveedor(pProveedor);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaEliminar,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
return(respuesta);
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pProveedor);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaProveedor {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Método que verifica si el registro se debe de autorizar o no
/// </summary>
/// <param name="controlador"></param>
/// <returns></returns>
public bool AutorizarRegistro(string controlador)
{
var controladorLN = new ControladorLogicaNegocio();
try
{
//obtenemos el controlador
var pControlador = new Controlador()
{
Codigo = controlador
};
var oControlador = controladorLN.ObtenerControlador(pControlador);
//validamos respuesta
if (oControlador.Respuesta.CodMensaje == Respuesta.CodExitoso &&
oControlador.Controlador != null)
{
return(oControlador.Controlador.Autorizar);
}
else
{
return(false);
}
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, controlador);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(false);
}
}
/// <summary>
/// Metodo que sirve para Obtener la lista de tipo Bitacora con paginacion
/// </summary>
/// <param name="pBitacora">Filtro de tipo Bitacora</param>
/// <param name="pPaginacion">Uso de Paginacion</param>
/// <returns></returns>
public RespuestaListaBitacoraAplicacion ObtenerBitacoraPaginado(BitacoraAplicacion pBitacora, Paginacion pPaginacion)
{
var respuesta = new RespuestaListaBitacoraAplicacion();
try
{
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pBitacora.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
pBitacora.IdEntidad = respS.Sesion.IdEntidad;
respuesta = dal.ObtenerBitacoraPaginado(pBitacora, pPaginacion);
return(respuesta);
}
else
{
return new RespuestaListaBitacoraAplicacion {
Respuesta = respS.Respuesta, ListaBitacora = new List <BitacoraAplicacion>()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pBitacora);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaListaBitacoraAplicacion {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo que sirve para Obtener la lista de tipo Catalogo
/// </summary>
/// <param name="pCatalogo">Filtro de tipo Catalogo</param>
/// <returns></returns>
public RespuestaListaCatalogo ObtenerListaCatalogo(Catalogo pCatalogo)
{
var respuesta = new RespuestaListaCatalogo();
try
{
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pCatalogo.UsrtokensAuthenticate
});
pCatalogo.IdEntidad = respS.Sesion.IdEntidad;
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
respuesta = dal.ObtenerCatalogos(pCatalogo);
return(respuesta);
}
else
{
return new RespuestaListaCatalogo {
Respuesta = respS.Respuesta, ListaCatalogo = new List <Catalogo>()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pCatalogo);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaListaCatalogo {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Obtiene una lista de roles por usuario
/// </summary>
/// <param name="pUsuario"></param>
/// <returns></returns>
public RespuestaListaRol ObtenerRolPorUsuario(Usuario pUsuario)
{
var respuesta = new RespuestaListaRol();
try
{
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pUsuario.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
respuesta = dal.ObtenerRolPorUsuario(pUsuario);
return(respuesta);
}
else
{
return new RespuestaListaRol {
Respuesta = respS.Respuesta, ListaRol = new List <Rol>()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaListaRol {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo para insertar un valor de tipo Producto
/// </summary>
/// <param name="pProducto"></param>
/// <returns></returns>
public RespuestaProducto InsertarProducto(Producto pProducto)
{
var respuesta = new RespuestaProducto();
try
{
//Registra en bd
respuesta = dal.InsertarProducto(pProducto);
//Registra bitacora
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaInsertar,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
return(respuesta);
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pProducto);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaProducto {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Método que inserta la primera autorización.
/// </summary>
/// <param name="pAutorizacion"></param>
public void PrimeraAutorizacion(Autorizacion pAutorizacion)
{
try
{
if (AutorizarRegistro(pAutorizacion.NombreControlador))
{
//se realiza la autorizacion
var oRespAutorizacion = dal.InsertarAutorizacion(pAutorizacion);
//validamos respuesta
if (oRespAutorizacion.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
//detalle
var pAutorizacionDetalle = new AutorizacionDetalle()
{
IdAutorizacion = oRespAutorizacion.Autorizacion.IdAutorizacion,
UsrAutorizador = pAutorizacion.UsrCreacion
};
//se guarda el detalle
dal.InsertarAutorizacionDetalle(pAutorizacionDetalle);
}
}
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pAutorizacion);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
}
}
/// <summary>
/// Valida el login de un usuario en el sistema.
/// </summary>
/// <param name="pUsuario"></param>
/// <returns></returns>
public RespuestaUsuario ValidarUsuarioLogin(Usuario pUsuario)
{
var respuesta = new RespuestaUsuario();
try
{
respuesta = dal.ValidarUsuarioLogin(pUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaValidacion,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
//Se valida error
if (respuesta.Respuesta.CodMensaje != Respuesta.CodExitoso)
{
//se procede a obtener el mensaje del error
var oResp = new Respuesta(respuesta.Respuesta.CodMensaje);
respuesta.Respuesta = oResp;
return(respuesta);
}
//si todo estuvo correcto se crea una sesion al usuario
var pSesion = new Sesion()
{
IdEntidad = pUsuario.IdEntidad,
CodigoUsuario = pUsuario.CodigoUsuario,
IP = pUsuario.IP
};
var RespSesion = sesion.InsertarSesion(pSesion);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaInsertar,
TraceData.Utilities.Enums.TypeTrace.Info, RespSesion, MethodBase.GetCurrentMethod().Name);
if (RespSesion.Respuesta.CodMensaje != Respuesta.CodExitoso)
{
respuesta.Respuesta = RespSesion.Respuesta;
return(respuesta);
}
//se da la respuesta con el token de sesion
var oSesion = RespSesion.Sesion;
respuesta.Usuario = new Usuario()
{
UsrtokensAuthenticate = oSesion.Token
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaUsuario {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
return(respuesta);
}
/// <summary>
/// Metodo que sirve para Enviar una Alerta
/// </summary>
/// <param name="pAlerta"></param>
/// <returns></returns>
public RespuestaAlertaEntidad EnviarAlerta <T>(ALERTAS alerta, T Object)
{
AlertaEntidadLogicaNegocio bl = new AlertaEntidadLogicaNegocio();
MessageTokenProviderLogicaNegocio tkn = new MessageTokenProviderLogicaNegocio();
CuentaEmailLogicaNegocio ctabl = new CuentaEmailLogicaNegocio();
string CorreoDestino = "";
string NombreDestino = "";
var tokens = new List <Token>();
var respuesta = new RespuestaAlertaEntidad();
try
{
respuesta = bl.ObtenerAlertaEntidad(new AlertaEntidad()
{
CodigoAlerta = alerta.ToString()
});
CuentaEmail cta = ctabl.ObtenerCuentaEmail(new CuentaEmail()
{
Id = respuesta.AlertaEntidad.IdCuenta
}).CuentaEmail;
switch (alerta)
{
/***********************************************************************************************/
/******************** Alertas de Usuario *****************************/
/***********************************************************************************************/
case ALERTAS.NewPassUser:
case ALERTAS.ForgoutPass:
case ALERTAS.LockedUser:
case ALERTAS.WrongPass:
Usuario usuario = (Usuario)Convert.ChangeType(Object, typeof(Usuario));
UsuarioLogicaNegocio ubl = new UsuarioLogicaNegocio();
usuario = ubl.ObtenerUsuario(usuario).Usuario;
tokens = tkn.AddUsuarioTokens(tokens, usuario);
CorreoDestino = usuario.CorreoElectronico;
NombreDestino = usuario.Nombre;
break;
}
string subject = Tokenizador(respuesta.AlertaEntidad.Titulo, tokens, false);
string body = Tokenizador(respuesta.AlertaEntidad.HtmlContent, tokens, true);
SendEmail(cta, subject, body, cta.CorreoElectronico, cta.Alias,
CorreoDestino, NombreDestino, null, null, null, null, null, null, 0, null);
return(respuesta);
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, alerta);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaAlertaEntidad {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo que sirve para Modificar un objeto de tipo Usuario
/// </summary>
/// <param name="pUsuario"></param>
/// <returns></returns>
public RespuestaUsuario ModificarUsuario(Usuario pUsuario)
{
var respuesta = new RespuestaUsuario();
try
{
string CodigoAlerta = "UsuarioEdit";
List <string> mensajes = new List <string>();
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pUsuario.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
//VALIDACION: Entidad no puede venir vacio
pUsuario.UsrModificacion = respS.Sesion.CodigoUsuario;
if (ValidacionesModificacion(pUsuario, ref mensajes))
{
//obtenemos los roles del usuario
pUsuario.XMLData = Util.SerializarObjeto(pUsuario.Roles);
respuesta = dal.ModificarUsuario(pUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaModificar,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
Notificacion(pUsuario, CodigoAlerta);
}
else
{
//NO COMPLETA LA VALIDACION, SE ENVIAN DE REGRESO LOS MENSAJES
respuesta = new RespuestaUsuario {
Respuesta = new Respuesta(Respuesta.CodNoValido), Usuario = respuesta.Usuario
};
}
return(respuesta);
}
else
{
return new RespuestaUsuario {
Respuesta = respS.Respuesta, Usuario = new Usuario()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaUsuario {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo que sirve para Eliminar o Desactivar un objeto de tipo AlertaEntidad
/// </summary>
/// <param name="pAlertaEntidad"></param>
/// <returns></returns>
public RespuestaAlertaEntidad EliminarAlertaEntidad(AlertaEntidad pAlertaEntidad)
{
var respuesta = new RespuestaAlertaEntidad();
try
{
string CodigoAlerta = "AlertaEntidadDelete";
List <string> mensajes = new List <string>();
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pAlertaEntidad.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
//VALIDACION: Entidad no puede venir vacio
pAlertaEntidad.IdEntidad = respS.Sesion.IdEntidad;
if (ValidacionesEliminar(pAlertaEntidad, ref mensajes))
{
//CONSULTA A ACCESO A DATOS
respuesta = dal.EliminarAlertaEntidad(pAlertaEntidad);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaEliminar,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
Notificacion(pAlertaEntidad, CodigoAlerta);
}
else
{
//NO COMPLETA LA VALIDACION, SE ENVIAN DE REGRESO LOS MENSAJES
respuesta = new RespuestaAlertaEntidad {
Respuesta = new Respuesta(Respuesta.CodNoValido), AlertaEntidad = respuesta.AlertaEntidad
};
}
return(respuesta);
}
else
{
return new RespuestaAlertaEntidad {
Respuesta = respS.Respuesta, AlertaEntidad = new AlertaEntidad()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pAlertaEntidad);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaAlertaEntidad {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo para insertar un valor de tipo AutorizacionDetalle
/// </summary>
/// <param name="pAutorizacionDetalle"></param>
/// <returns></returns>
public RespuestaAutorizacionDetalle InsertarAutorizacionDetalle(AutorizacionDetalle pAutorizacionDetalle)
{
var respuesta = new RespuestaAutorizacionDetalle();
try
{
string CodigoAlerta = "AutorizacionDetalleCreate";
List <string> mensajes = new List <string>();
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pAutorizacionDetalle.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
pAutorizacionDetalle.UsrCreacion = respS.Sesion.CodigoUsuario;
//EJECUTAR: se guarda la entidad
if (ValidacionesCreacion(pAutorizacionDetalle, ref mensajes))
{
respuesta = dal.InsertarAutorizacionDetalle(pAutorizacionDetalle);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaInsertar,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
Notificacion(pAutorizacionDetalle, CodigoAlerta);
}
else
{
//NO COMPLETA LA VALIDACION, SE ENVIAN DE REGRESO LOS MENSAJES
respuesta = new RespuestaAutorizacionDetalle {
Respuesta = new Respuesta(Respuesta.CodNoValido), AutorizacionDetalle = respuesta.AutorizacionDetalle
};
}
return(respuesta);
}
else
{
return new RespuestaAutorizacionDetalle {
Respuesta = respS.Respuesta, AutorizacionDetalle = new AutorizacionDetalle()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pAutorizacionDetalle);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaAutorizacionDetalle {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Método que procesa la siguiente autorizacion
/// </summary>
/// <param name="pAutorizacion"></param>
/// <returns></returns>
public RespuestaAutorizacion ProcesarAutorizacion(Autorizacion pAutorizacion)
{
var respuesta = new RespuestaAutorizacion();
try
{
//string CodigoAlerta = "ValidarAutorizacionCreate";
List <string> mensajes = new List <string>();
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pAutorizacion.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
pAutorizacion.UsrCreacion = respS.Sesion.CodigoUsuario;
//EJECUTAR: se guarda la entidad
respuesta = dal.ProcesarAutorizacion(pAutorizacion);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaValidacion,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
if (respuesta.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
//se envia la notificacion segun corresponda
Task.Factory.StartNew(() => Notificacion(pAutorizacion));
}
return(respuesta);
}
else
{
return new RespuestaAutorizacion {
Respuesta = respS.Respuesta, Autorizacion = new Autorizacion()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pAutorizacion);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaAutorizacion {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo que sirve para Obtener la lista de tipo AlertaEntidad
/// </summary>
/// <param name="pAlertaEntidad">Filtro de tipo AlertaEntidad</param>
/// <returns></returns>
public RespuestaAlertaEntidad ObtenerAlertaEntidad(AlertaEntidad pAlertaEntidad)
{
var respuesta = new RespuestaAlertaEntidad();
try
{
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pAlertaEntidad.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
pAlertaEntidad.IdEntidad = respS.Sesion.IdEntidad;
respuesta.AlertaEntidad = dal.ObtenerAlertaEntidad(pAlertaEntidad).ListaAlertaEntidad?[0];
return(respuesta.AlertaEntidad != null ?
new RespuestaAlertaEntidad {
Respuesta = new Respuesta(string.Empty, Respuesta.CodExitoso), AlertaEntidad = respuesta.AlertaEntidad
} :
new RespuestaAlertaEntidad {
Respuesta = new Respuesta(Respuestas.GI03, Respuesta.CodExitoso), AlertaEntidad = new AlertaEntidad()
});
}
else
{
return new RespuestaAlertaEntidad {
Respuesta = respS.Respuesta, AlertaEntidad = new AlertaEntidad()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pAlertaEntidad);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaAlertaEntidad {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo que sirve para Obtener la lista de tipo Bitacora
/// </summary>
/// <param name="pBitacora">Filtro de tipo Bitacora</param>
/// <returns></returns>
public RespuestaBitacoraAplicacion ObtenerBitacora(BitacoraAplicacion pBitacora)
{
var respuesta = new RespuestaBitacoraAplicacion();
try
{
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pBitacora.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
respuesta.Bitacora = dal.ObtenerBitacora(pBitacora).ListaBitacora?[0];
return(respuesta.Bitacora != null ?
new RespuestaBitacoraAplicacion {
Respuesta = new Respuesta(string.Empty, Respuesta.CodExitoso), Bitacora = respuesta.Bitacora
} :
new RespuestaBitacoraAplicacion {
Respuesta = new Respuesta(Respuestas.GI03, Respuesta.CodExitoso), Bitacora = new BitacoraAplicacion()
});
}
else
{
return new RespuestaBitacoraAplicacion {
Respuesta = respS.Respuesta, Bitacora = new BitacoraAplicacion()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pBitacora);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaBitacoraAplicacion {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo que sirve para Obtener la lista de tipo Producto con paginacion
/// </summary>
/// <param name="pProducto">Filtro de tipo Producto</param>
/// <param name="pPaginacion">Uso de Paginacion</param>
/// <returns></returns>
public RespuestaListaProducto ObtenerProductoPaginado(Producto pProducto, ref Paginacion pPaginacion)
{
var respuesta = new RespuestaListaProducto();
try
{
respuesta = dal.ObtenerProductoPaginado(pProducto, ref pPaginacion);
return(respuesta);
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pProducto);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaListaProducto {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Método que cambia la contraseña del usuario
/// </summary>
/// <param name="pUsuario"></param>
/// <returns></returns>
public RespuestaUsuario CambiarContrasena(Usuario pUsuario)
{
var respuesta = new RespuestaUsuario();
try
{
string CodigoAlerta = "UsuarioCambioPass";
//validamos la contraseña a cambiar
var oRespContrasena = ValidarContrasenna(pUsuario);
if (oRespContrasena.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
respuesta = dal.CambiarContrasena(pUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaCambioContrasena,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
Notificacion(pUsuario, CodigoAlerta);
return(respuesta);
}
else
{
return(oRespContrasena);
}
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaUsuario {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo para insertar un valor de tipo Rol
/// </summary>
/// <param name="pRol"></param>
/// <returns></returns>
public RespuestaRol InsertarRol(Rol pRol)
{
var respuesta = new RespuestaRol();
try
{
string CodigoAlerta = "RolCreate";
List <string> mensajes = new List <string>();
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pRol.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
pRol.UsrCreacion = respS.Sesion.CodigoUsuario;
//EJECUTAR: se guarda la entidad
if (ValidacionesCreacion(pRol, ref mensajes))
{
//obtenemos la lista de roles
pRol.XMLData = Util.SerializarObjeto(pRol.Perfiles);
respuesta = dal.InsertarRol(pRol);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaInsertar,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
//Se valida error
if (respuesta.Respuesta.CodMensaje != Respuesta.CodExitoso)
{
//se procede a obtener el mensaje del error
var oResp = new Respuesta(respuesta.Respuesta.CodMensaje);
if (string.IsNullOrEmpty(oResp.Mensaje))
{
oResp.Mensaje = Mensajes.msjErrorGenerico;
}
respuesta.Respuesta = oResp;
return(respuesta);
}
Notificacion(pRol, CodigoAlerta);
//****Se envia a crear la primera autorización***
Task.Factory.StartNew(() => InsertarAutorizacion(respuesta.Rol));
//***********************************************
}
else
{
//NO COMPLETA LA VALIDACION, SE ENVIAN DE REGRESO LOS MENSAJES
respuesta = new RespuestaRol {
Respuesta = new Respuesta(Respuesta.CodNoValido), Rol = respuesta.Rol
};
}
return(respuesta);
}
else
{
return new RespuestaRol {
Respuesta = respS.Respuesta, Rol = new Rol()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pRol);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaRol {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Metodo para insertar un valor de tipo Usuario
/// </summary>
/// <param name="pUsuario"></param>
/// <returns></returns>
public RespuestaUsuario InsertarUsuario(Usuario pUsuario)
{
var respuesta = new RespuestaUsuario();
try
{
string CodigoAlerta = "UsuarioCreate";
List <string> mensajes = new List <string>();
RespuestaSesion respS = sesion.ObtenerSesion(new Sesion()
{
Token = pUsuario.UsrtokensAuthenticate
});
if (respS.Respuesta.CodMensaje == Respuesta.CodExitoso)
{
pUsuario.UsrCreacion = respS.Sesion.CodigoUsuario;
//**** Contraseña temporal para el nuevo usuario*****
//TODO: encriptar contraseña
string clave = new LnGenPassword().GetNewPassword();
//encriptamos la clave
pUsuario.Clave = oEncriptador.Encriptar(clave);
//EJECUTAR: se guarda la entidad
if (ValidacionesCreacion(pUsuario, ref mensajes))
{
//se define los datos necesarios para el usuario
pUsuario.IdEntidad = respS.Sesion.IdEntidad;
//obtenemos los roles del usuario
pUsuario.XMLData = Util.SerializarObjeto(pUsuario.Roles);
respuesta = dal.InsertarUsuario(pUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.RespuestaInsertar,
TraceData.Utilities.Enums.TypeTrace.Info, respuesta, MethodBase.GetCurrentMethod().Name);
Notificacion(pUsuario, CodigoAlerta);
//Se valida error
if (respuesta.Respuesta.CodMensaje != Respuesta.CodExitoso)
{
//se procede a obtener el mensaje del error
var oResp = new Respuesta(respuesta.Respuesta.CodMensaje);
if (string.IsNullOrEmpty(oResp.Mensaje))
{
oResp.Mensaje = Mensajes.msjErrorGenerico;
}
respuesta.Respuesta = oResp;
return(respuesta);
}
//****Se envia a crear la primera autorización***
Task.Factory.StartNew(() => InsertarAutorizacion(respuesta.Usuario));
//***********************************************
}
else
{
//NO COMPLETA LA VALIDACION, SE ENVIAN DE REGRESO LOS MENSAJES
respuesta = new RespuestaUsuario {
Respuesta = new Respuesta(Respuesta.CodNoValido), Usuario = respuesta.Usuario
};
}
return(respuesta);
}
else
{
return new RespuestaUsuario {
Respuesta = respS.Respuesta, Usuario = new Usuario()
}
};
}
catch (Exception ex)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(ex, pUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, ex, MethodBase.GetCurrentMethod().Name);
return(new RespuestaUsuario {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, ex.Message, Respuesta.CodNoValido)
});
}
}
/// <summary>
/// Método que valida la contraseña del usuario.
/// </summary>
/// <param name="oUsuario"></param>
/// <returns></returns>
public RespuestaUsuario ValidarContrasenna(Usuario oUsuario)
{
var oRespuesta = new RespuestaUsuario {
Respuesta = new Respuesta()
{
CodMensaje = Respuesta.CodError
}
};
try
{
var catalogoLn = new CatalogoLogicaNegocio();
//desencriptamos la contraseña enviada
string clave = oEncriptador.DesEncriptar(oUsuario.Clave);
/************* Obtener Longitud *******************/
var longitudPassword = Convert.ToInt32(catalogoLn.ObtenerCatalogo(new Catalogo()
{
CodigoParametro = Constantes.Catalogo.LongitudPassword
}).Catalogo.Identificador);
/************* Obtener Numeros *******************/
var cantidadNumeros = Convert.ToInt32(catalogoLn.ObtenerCatalogo(new Catalogo()
{
CodigoParametro = Constantes.Catalogo.CntMinNumPassword
}).Catalogo.Identificador);
/************* Obtener Mayusculas *******************/
var cantidadMayusculas = Convert.ToInt32(catalogoLn.ObtenerCatalogo(new Catalogo()
{
CodigoParametro = Constantes.Catalogo.CntMinMayusculasPassword
}).Catalogo.Identificador);
/************* Obtener Simbolos *******************/
var cantidadSimbolos = Convert.ToInt32(catalogoLn.ObtenerCatalogo(new Catalogo()
{
CodigoParametro = Constantes.Catalogo.CntMinSimbolosPassword
}).Catalogo.Identificador);
int contNum = 0; int contMayus = 0; int contSymbol = 0;
foreach (char c in clave)
{
if (char.IsNumber(c))
{
contNum++;
}
else if (char.IsUpper(c))
{
contMayus++;
}
else if (char.IsSymbol(c) | char.IsPunctuation(c))
{
contSymbol++;
}
}
var oMensajes = new List <string>();
//Valida la cantidad mínima de caracteres
if (oUsuario.Clave.Length < longitudPassword)
{
oMensajes.Add(string.Format(MensajesValidaciones.PassMinCaracteres, longitudPassword));
}
//Valida la cantidad mínima de números
if (contNum < cantidadNumeros)
{
oMensajes.Add(string.Format(MensajesValidaciones.PassMinNumeros, cantidadNumeros));
}
//Valida la cantidad mínima de mayúsculas
if (contMayus < cantidadMayusculas)
{
oMensajes.Add(string.Format(MensajesValidaciones.PassMinMayusculas, cantidadMayusculas));
}
//Valida la cantidad mínima de símbolos
if (contSymbol < cantidadSimbolos)
{
oMensajes.Add(string.Format(MensajesValidaciones.PassMinSimbolos, cantidadSimbolos));
}
if (oMensajes.Count != 0)
{
//Contraseña incorrecta
oRespuesta.Respuesta.Mensaje = oMensajes.FirstOrDefault();
oRespuesta.Respuesta.Mensajes = oMensajes;
return(oRespuesta);
}
//contraseña correcta
return(new RespuestaUsuario()
{
Respuesta = new Respuesta()
{
CodMensaje = Respuesta.CodExitoso
}
});
}
catch (Exception oException)
{
ControlExcepciones.ControlExcepciones.ManejoExcepciones(oException, oUsuario);
BitacoraLogicaNegocios.RegistrarBitacora(MENSAJES_SISTEMA.ErrorExcepcion,
TraceData.Utilities.Enums.TypeTrace.Exception, oException, MethodBase.GetCurrentMethod().Name);
return(new RespuestaUsuario {
Respuesta = new Respuesta(TipoRespuesta.Excepcion, oException.Message, Respuesta.CodNoValido)
});
}
}
