Пример #1
0
        /// <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)
                });
            }
        }
Пример #2
0
        /// <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)
                });
            }
        }
Пример #3
0
        /// <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);
            }
        }
Пример #4
0
        /// <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)
                });
            }
        }
Пример #5
0
        /// <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)
                });
            }
        }
Пример #6
0
        /// <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)
                });
            }
        }
Пример #7
0
        /// <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)
                });
            }
        }
Пример #8
0
        /// <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);
            }
        }
Пример #9
0
        /// <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);
        }
Пример #10
0
        /// <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)
                });
            }
        }
Пример #11
0
        /// <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)
                });
            }
        }
Пример #12
0
        /// <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)
                });
            }
        }
Пример #13
0
        /// <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)
                });
            }
        }
Пример #14
0
        /// <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)
                });
            }
        }
Пример #15
0
        /// <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)
                });
            }
        }
Пример #16
0
        /// <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)
                });
            }
        }
Пример #17
0
        /// <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)
                });
            }
        }
Пример #18
0
        /// <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)
                });
            }
        }
Пример #19
0
        /// <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)
                });
            }
        }
Пример #20
0
        /// <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)
                });
            }
        }
Пример #21
0
        /// <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)
                });
            }
        }