Exemple #1
0
        public static string ObtenerUsuario()
        {
            BEUsuarioValidoResponse oUsuario = new BEUsuarioValidoResponse();

            oUsuario = DeserializeUsuario();
            return(oUsuario.desLogin);
        }
Exemple #2
0
        public static List <BEUsuarioPermisoResponse> DeserializeRoles(string p_desEnlaceURL_WIN, bool p_appWindows)
        {
            List <BEUsuarioPermisoResponse> listaRoles = new List <BEUsuarioPermisoResponse>();
            List <BEUsuarioPermisoResponse> miRol      = new List <BEUsuarioPermisoResponse>();

            try
            {
                BEUsuarioValidoResponse userValido = new BEUsuarioValidoResponse();
                userValido = DeserializeUsuario();
                listaRoles = userValido.lstObjeto.ToList <BEUsuarioPermisoResponse>();
                if (p_appWindows)
                {
                    var query = from item in listaRoles
                                where item.desEnlaceWIN == p_desEnlaceURL_WIN
                                select item;

                    miRol = query.ToList <BEUsuarioPermisoResponse>();
                }
                else
                {
                    var query = from item in listaRoles
                                where item.desEnlaceURL == p_desEnlaceURL_WIN
                                select item;

                    miRol = query.ToList <BEUsuarioPermisoResponse>();
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return(miRol);
        }
Exemple #3
0
 public OperationResult GetRenovarToken(BEUsuarioValidoResponse pUserValidated)
 {
     try
     {
         pUserValidated.Token = GetToken(pUserValidated);
         return(OK(pUserValidated));
     }
     catch (Exception ex)
     {
         return(Error(GetType().Name, MethodBase.GetCurrentMethod().Name, ex, pUserValidated.desLogin, ""));
     }
 }
Exemple #4
0
        public static async Task <BEUsuarioValidoResponse> ValidarInicioSesionAsync(BELoginModel plogin)
        {
            BEUsuarioValidoResponse pUserValido = new BEUsuarioValidoResponse();

            try
            {
                var BELogueo = new
                {
                    Login       = plogin.Usuario,
                    Contrasenia = plogin.Contrasenia,
                    KeySistema  = GlobalSettings.GetDEFAULT_KEY_SYSTEM()
                };

                using (var client = new HttpClient())
                {
                    HttpContent        content = new StringContent(JsonConvert.SerializeObject(BELogueo), Encoding.UTF8, "application/json");
                    Uri                uriURL  = new Uri(string.Concat(GlobalSettings.GetDEFAULT_URL_WS_API_Seguridad(), "api/security/getvalidateuser"));
                    HttpRequestMessage request = new HttpRequestMessage
                    {
                        Method     = HttpMethod.Post,
                        RequestUri = uriURL,
                        Content    = content,
                    };

                    HttpResponseMessage result = await client.SendAsync(request);

                    var responseBody = await result.Content.ReadAsStringAsync();

                    ResponseHttpClient jsonResul = JsonConvert.DeserializeObject <ResponseHttpClient>(responseBody);

                    if (!result.IsSuccessStatusCode)
                    {
                        pUserValido.ResultIndValido = jsonResul.IsSuccess;
                        pUserValido.ResultIMessage  = jsonResul.Message;
                        return(pUserValido);
                    }

                    pUserValido = JsonConvert.DeserializeObject <BEUsuarioValidoResponse>(responseBody);
                    pUserValido.ResultIndValido = true;
                }
            }
            catch (Exception ex)
            {
                var oReturnValor = HelpException.mTraerMensaje(ex, true, string.Concat("ValidarInicioSesion.", MethodBase.GetCurrentMethod().Name), plogin.Usuario);
                throw new Exception(oReturnValor.Message);
            }
            return(pUserValido);
        }
Exemple #5
0
        public static List <BEUsuarioPermisoResponse> DeserializeRoles()
        {
            List <BEUsuarioPermisoResponse> listaRol = new List <BEUsuarioPermisoResponse>();

            try
            {
                BEUsuarioValidoResponse usuarioValidado = new BEUsuarioValidoResponse();
                usuarioValidado = DeserializeUsuario();
                listaRol        = usuarioValidado.lstObjeto.ToList <BEUsuarioPermisoResponse>();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return(listaRol);
        }
Exemple #6
0
        public BEUsuarioValidoResponse DetectLoginPasswordValid(string pdesLogin, string pPassword, string pKeySistema, string pNumIP)
        {
            BEUsuarioValidoResponse objUsuarioValidado = null;

            try
            {
                var operationResult = (new SeguridadLogic()).ValidarUsuario(pdesLogin, pPassword, pKeySistema, pNumIP);
                if (operationResult.isValid)
                {
                    objUsuarioValidado = JsonConvert.DeserializeObject <BEUsuarioValidoResponse>(operationResult.data);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(objUsuarioValidado);
        }
Exemple #7
0
        public static BEUsuarioPermisoResponse DeserializeRolOpcion(string p_desEnlaceURL_WIN, bool p_appWindows)
        {
            BEUsuarioPermisoResponse ItemOpcion = new BEUsuarioPermisoResponse();

            try
            {
                BEUsuarioValidoResponse oUsuarioValido = new BEUsuarioValidoResponse();
                oUsuarioValido = DeserializeUsuario();
                var misRoles = oUsuarioValido.lstObjeto.ToList <BEUsuarioPermisoResponse>();
                if (p_appWindows)
                {
                    var query = from item in misRoles
                                where item.desEnlaceWIN == p_desEnlaceURL_WIN
                                select item;
                    if (query.ToList <BEUsuarioPermisoResponse>().Count() == 1)
                    {
                        ItemOpcion = query.ToList <BEUsuarioPermisoResponse>()[0];
                    }
                    else
                    {
                        ItemOpcion = null;
                    }
                }
                else
                {
                    var query = from item in misRoles
                                where item.desEnlaceURL == p_desEnlaceURL_WIN
                                select item;
                    if (query.ToList <BEUsuarioPermisoResponse>().Count() == 1)
                    {
                        ItemOpcion = query.ToList <BEUsuarioPermisoResponse>()[0];
                    }
                    else
                    {
                        ItemOpcion = null;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return(ItemOpcion);
        }
Exemple #8
0
 internal static void SerializarUsuario(BEUsuarioValidoResponse pUsuario)
 {
     try
     {
         // Crear Archivo para Guardar los Datos de La Clase
         FileStream fs = new FileStream(msPathWork + msFileUser, FileMode.Create);
         // Crear un Objeto XmlSerializer to perform the serialization
         XmlSerializer xs = new XmlSerializer(typeof(BEUsuarioValidoResponse));
         // Use the XmlSerializer object to serialize the data to the file
         xs.Serialize(fs, pUsuario);
         // Close the file
         fs.Close();
         return;
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Exemple #9
0
        public BEUsuarioValidoResponse FindLoginValidated(string prm_LoginUsuario)
        {
            BEUsuarioValidoResponse objUsuario = null;

            try
            {
                using (DBML_AccesoDataContext SeguridadDC = new DBML_AccesoDataContext(conexion))
                {
                    var resul = SeguridadDC.omgc_pro_SIS_Usuario_LoginValidated(prm_LoginUsuario);
                    foreach (var item in resul)
                    {
                        objUsuario = new BEUsuarioValidoResponse();

                        objUsuario.codUsuario          = item.codUsuario;
                        objUsuario.desLogin            = item.desLogin;
                        objUsuario.desNombre           = item.desNombres;
                        objUsuario.desApellido         = item.desApellidos;
                        objUsuario.desNombreUsuario    = string.Concat(item.desNombres, " ", item.desApellidos);
                        objUsuario.desTelefono         = item.desTelefono;
                        objUsuario.desCorreo           = item.desCorreo;
                        objUsuario.codEmpleado         = item.codEmpleado;
                        objUsuario.indVendedor         = item.indVendedor;
                        objUsuario.indCambioPrecio     = item.indCambioPrecio;
                        objUsuario.indAccesoGerencial  = item.indAccesoGerencial;
                        objUsuario.indCambiaDescuento  = item.indCambiaDescuento;
                        objUsuario.indCambiaCodPersona = item.indCambiaCodPersona;
                        objUsuario.indJefeCaja         = item.indJefeCaja;
                        objUsuario.indUsuarioSistema   = item.indUsuarioSistema;
                        objUsuario.codSistemaNombre    = item.codSistemaNombre;
                        objUsuario.codRolNombre        = item.codRolNombre;
                        objUsuario.codEmpresaNombre    = item.codEmpresaNombre;
                        objUsuario.urlPhotoUser        = item.urlPhotoUser;
                        objUsuario.indOrigenUser       = item.indOrigenUser;
                        objUsuario.codGUID             = item.codGUID;
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(objUsuario);
        }
Exemple #10
0
        public static BEUsuarioValidoResponse ValidarInicioSesion(string pUsuario, string pContrasenia, string pGetDEFAULT_KEY_SYSTEM)
        {
            BEUsuarioValidoResponse pUserValido = new BEUsuarioValidoResponse();

            try
            {
                var BELogueo = new
                {
                    Login       = pUsuario,
                    Contrasenia = pContrasenia,
                    KeySistema  = pGetDEFAULT_KEY_SYSTEM
                };

                bool hasError = false;
                Uri  uriURL   = new Uri(string.Concat(GlobalSettings.GetDEFAULT_URL_WS_API_Seguridad(),
                                                      WebConstants.URI_SEGURIDAD_POST_VALIDATE_USER));

                string responseBody = HelperWeb.ProcessRequest(uriURL.AbsoluteUri, WebConstants.METHOD_POST,
                                                               JsonConvert.SerializeObject(BELogueo),
                                                               WebConstants.CONTENT_TYPE_JSON, ref hasError);

                if (!hasError)
                {
                    pUserValido = JsonConvert.DeserializeObject <BEUsuarioValidoResponse>(responseBody);
                }
                else
                {
                    ResponseHttpClient jsonResul = JsonConvert.DeserializeObject <ResponseHttpClient>(responseBody);
                    pUserValido.ResultIndValido = jsonResul.IsSuccess;
                    pUserValido.ResultIMessage  = jsonResul.Message;

                    return(pUserValido);
                }
            }
            catch (Exception ex)
            {
                var oReturnValor = HelpException.mTraerMensaje(ex, true,
                                                               string.Concat("ValidarInicioSesion.", MethodBase.GetCurrentMethod().Name), pUsuario);
                throw new Exception(oReturnValor.Message);
            }
            return(pUserValido);
        }
Exemple #11
0
        public BEUsuarioValidoResponse DetectLoginPasswordValidWSAPI(string pdesLogin, string pPassword)
        {
            BEUsuarioValidoResponse usuarioValidado = null;

            try
            {
                BELoginModel plogin = new BELoginModel
                {
                    Contrasenia = pPassword,
                    Usuario     = pdesLogin,
                };

                usuarioValidado = ApiServiceSeguridad.ValidarInicioSesion(plogin);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(usuarioValidado);
        }
Exemple #12
0
        public static BEUsuarioValidoResponse DeserializeUsuario()
        {
            BEUsuarioValidoResponse miUsuario = new BEUsuarioValidoResponse();

            try
            {
                // Crear file to save the data to
                FileStream fs = new FileStream(msPathWork + msFileUser, FileMode.Open);
                // Crear un Objeto XmlSerializer para perform the deserialization
                XmlSerializer xs = new XmlSerializer(typeof(BEUsuarioValidoResponse));
                // Use the XmlSerializer object to deserialize the data to the file
                miUsuario = (BEUsuarioValidoResponse)xs.Deserialize(fs);
                // Close the file
                fs.Close();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return(miUsuario);
        }
Exemple #13
0
        public string GetToken(BEUsuarioValidoResponse objUsuarioValidado)
        {
            EmpresaSistemaData oEmpresaSistemaData = new EmpresaSistemaData();
            BEEmpresaSistema   oEmpresaSistema     = oEmpresaSistemaData.Find(objUsuarioValidado.codEmpresa,
                                                                              objUsuarioValidado.codSistema);

            return(StringExtensions.OfuscateUrl(string.Format("{0}|{1}|{2}|{3}|{4}|{5}|{6}|{7}|{8}|{9}|{10}|{11}|{12}",
                                                              /* 00  */ objUsuarioValidado.codUsuario,
                                                              /* 01  */ objUsuarioValidado.codEmpleado,
                                                              /* 02  */ objUsuarioValidado.desLogin,
                                                              /* 03  */ objUsuarioValidado.desCorreo,
                                                              /* 04  */ objUsuarioValidado.desNombreUsuario,
                                                              /* 05  */ objUsuarioValidado.codEmpresa,
                                                              /* 06  */ objUsuarioValidado.codEmpresaNombre,
                                                              /* 07  */ objUsuarioValidado.numRUC,
                                                              /* 08  */ objUsuarioValidado.codSistema,
                                                              /* 09  */ objUsuarioValidado.codSistemaNombre,
                                                              /* 10  */ objUsuarioValidado.codRol,
                                                              /* 11  */ objUsuarioValidado.codRolNombre,
                                                              /* 12  */ HelpTime.DateTimeToUnixTimestamp(DateTime.Now.AddHours(GlobalSettings.GetDEFAULT_HorasFechaActualCloud()).AddHours(
                                                                                                             oEmpresaSistema.numTiempoToken == 0 ? 24 :
                                                                                                             oEmpresaSistema.numTiempoToken)).ToString())
                                                ));
        }
Exemple #14
0
        private OperationResult ValidarAccesoUsuarioSistemaEmpresa(BEUsuarioValidoResponse objUsuarioValidado, string pKeySistema)
        {
            var operationResult = new OperationResult();

            operationResult.isValid = false;
            if (string.IsNullOrEmpty(objUsuarioValidado.codEmpresaNombre) && objUsuarioValidado.codEmpleado != "EXT")
            {
                operationResult.brokenRulesCollection.Add(new BrokenRule
                {
                    description = WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == 2006).Value,
                    severity    = RuleSeverity.Warning
                });
                return(operationResult);
            }
            else if (string.IsNullOrEmpty(objUsuarioValidado.codSistemaNombre))
            {
                operationResult.brokenRulesCollection.Add(new BrokenRule
                {
                    description = WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == 2007).Value,
                    severity    = RuleSeverity.Warning
                });
                return(operationResult);
            }
            else if (string.IsNullOrEmpty(objUsuarioValidado.codRolNombre))
            {
                operationResult.brokenRulesCollection.Add(new BrokenRule
                {
                    description = WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == 2008).Value,
                    severity    = RuleSeverity.Warning
                });
                return(operationResult);
            }

            //Validar si esta asignado a una empresa
            //365A01B7-6C8E-460E-90F4-29C52D6CADD7|1|Sistema SIS|10181980325,
            //0E48ADC1-21B7-465B-858E-F3A3C608CEB1|2|Sistema GC|10181980327
            bool     blnEmpresaEsValido = false;
            string   strEmpresa         = string.Empty;
            string   strnumRUC          = string.Empty;
            DateTime?fecLicenciaVenc    = null;
            int      numCodigoError     = 0;

            if (objUsuarioValidado.codEmpleado != "EXT")
            {
                //HelpLogging.Write(TraceLevel.Warning, string.Concat(GetType().Name, ".", MethodBase.GetCurrentMethod().Name),
                //                  objUsuarioValidado.codEmpresaNombre,
                //                  string.Format("Empresa:[{0}], Usuario:[{1}]", "00", objUsuarioValidado.desLogin));

                string[] arrEmpresas = objUsuarioValidado.codEmpresaNombre.Split(',');
                foreach (string itemEmpresa in arrEmpresas)
                {
                    string[] arrDatoEmpresa = itemEmpresa.Split('|');

                    //HelpLogging.Write(TraceLevel.Info, string.Concat(GetType().Name,".", MethodBase.GetCurrentMethod().Name),
                    //              string.Format("arrDatoEmpresa[{0}].Trim() == pKeySistema({1})", arrDatoEmpresa[0].Trim(), pKeySistema),
                    //              string.Format("Empresa:[{0}], Usuario:[{1}]", "00", objUsuarioValidado.desLogin));

                    if (arrDatoEmpresa[0].Trim() == pKeySistema)
                    {
                        //HelpLogging.Write(TraceLevel.Info, string.Concat(GetType().Name, ".", MethodBase.GetCurrentMethod().Name),
                        //          string.Format("ConvertYYYYMMDDToDate:[ {0} ] == DateTime.Now=[ {1} ]", HelpTime.ConvertYYYYMMDDToDate(arrDatoEmpresa[1].Trim()),
                        //                                                                                 DateTime.Now.AddHours(GlobalSettings.GetDEFAULT_HorasFechaActualCloud())),
                        //          string.Format("Empresa:[{0}], Usuario:[{1}]", "00", objUsuarioValidado.desLogin));

                        if (HelpTime.ConvertYYYYMMDDToDate(arrDatoEmpresa[1].Trim()) > DateTime.Now.AddHours(GlobalSettings.GetDEFAULT_HorasFechaActualCloud()))
                        {
                            blnEmpresaEsValido            = true;
                            numCodigoError                = 0;
                            objUsuarioValidado.codEmpresa = Extensors.CheckInt(arrDatoEmpresa[2]);
                            strEmpresa = arrDatoEmpresa[3].Trim();
                            strnumRUC  = arrDatoEmpresa[4].Trim();
                            break;
                        }
                        else
                        {
                            numCodigoError  = 2011;
                            strEmpresa      = arrDatoEmpresa[3].Trim();
                            fecLicenciaVenc = HelpTime.ConvertYYYYMMDDToDate(arrDatoEmpresa[1].Trim());
                            HelpLogging.Write(TraceLevel.Warning, string.Concat(GetType().Name, ".", MethodBase.GetCurrentMethod().Name),
                                              string.Format("numCodigoError:[ {0} ] == DateTime.Now=[ {1} ]", numCodigoError,
                                                            DateTime.Now.AddHours(GlobalSettings.GetDEFAULT_HorasFechaActualCloud())),
                                              string.Format("Empresa:[{0}], Usuario:[{1}]", "00", objUsuarioValidado.desLogin));
                            break;
                        }
                    }
                    else
                    {
                        numCodigoError = 2010;
                        HelpLogging.Write(TraceLevel.Warning, string.Concat(GetType().Name, MethodBase.GetCurrentMethod().Name),
                                          string.Format("numCodigoError:[ {0} ] == DateTime.Now=[ {1} ]", numCodigoError,
                                                        DateTime.Now.AddHours(GlobalSettings.GetDEFAULT_HorasFechaActualCloud())),
                                          string.Format("Empresa:[{0}], Usuario:[{1}]", "00", objUsuarioValidado.desLogin));
                    }
                }

                if (!blnEmpresaEsValido)
                {
                    if (numCodigoError == 2011)
                    {
                        operationResult.brokenRulesCollection.Add(new BrokenRule
                        {
                            description = string.Format(WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == numCodigoError).Value,
                                                        strEmpresa, fecLicenciaVenc.Value.ToShortDateString()),
                            severity = RuleSeverity.Warning
                        });
                    }
                    else
                    {
                        operationResult.brokenRulesCollection.Add(new BrokenRule
                        {
                            description = WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == numCodigoError).Value,
                            severity    = RuleSeverity.Warning
                        });
                    }
                    return(operationResult);
                }

                objUsuarioValidado.codEmpresaNombre = strEmpresa;
                objUsuarioValidado.numRUC           = strnumRUC;
            }

            //Validar si esta asignado al sistema
            //365A01B7-6C8E-460E-90F4-29C52D6CADD7|1|Sistema SIS,
            //0E48ADC1-21B7-465B-858E-F3A3C608CEB1|2|Sistema GC
            bool   blnSistemaEsValido = false;
            string strSistema         = string.Empty;

            string[] arrSistemas = objUsuarioValidado.codSistemaNombre.Split(',');
            foreach (string itemSistema in arrSistemas)
            {
                string[] strValoresSistema = itemSistema.Split('|');
                if (strValoresSistema[0].Trim() == pKeySistema)
                {
                    strSistema = strValoresSistema[2].Trim();
                    objUsuarioValidado.codSistema = strValoresSistema[1].Trim();
                    blnSistemaEsValido            = true;
                    break;
                }
            }
            if (!blnSistemaEsValido)
            {
                operationResult.brokenRulesCollection.Add(new BrokenRule
                {
                    description = WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == 2009).Value,
                    severity    = RuleSeverity.Warning
                });
                return(operationResult);
            }
            objUsuarioValidado.codSistemaNombre = strSistema;
            //Validar si esta asignado a un rol
            //365A01B7-6C8E-460E-90F4-29C52D6CADD7|1|Administrador,
            //0E48ADC1-21B7-465B-858E-F3A3C608CEB1|15|Administrador
            bool   blnUsuarioEsValido = false;
            string strRol             = string.Empty;

            string[] arrRolesUsuario = objUsuarioValidado.codRolNombre.Split(',');
            foreach (string itemRolesUsuario in arrRolesUsuario)
            {
                string[] strValoresRolesUsuario = itemRolesUsuario.Split('|');
                if (strValoresRolesUsuario[0].Trim() == pKeySistema)
                {
                    strRol = strValoresRolesUsuario[2].Trim();
                    objUsuarioValidado.codRol = strValoresRolesUsuario[1].Trim();
                    blnUsuarioEsValido        = true;
                    break;
                }
            }
            if (!blnUsuarioEsValido)
            {
                operationResult.brokenRulesCollection.Add(new BrokenRule
                {
                    description = WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == 2012).Value,
                    severity    = RuleSeverity.Warning
                });
                return(operationResult);
            }

            objUsuarioValidado.codRolNombre = strRol;
            operationResult.isValid         = true;
            return(operationResult);
        }
Exemple #15
0
        /// <summary>
        /// Metodo                  :DetectarUsuario
        /// Propósito               :Permite detectar la existencia del usuario con Login y Contrasenia
        /// Retorno                 :Verdadero o Falso
        /// Autor                   :OCR - Orlando Carril R.
        /// Fecha/Hora de Creación  :22/10/2015
        /// Modificado              :N/A
        /// Fecha/Hora Modificación :N/A
        /// </summary>
        /// <param name="pdesLogin">Login del usuario</param>
        /// <param name="pclvContrasenia">Contraseña del usuario</param>
        /// <returns></returns>
        public OperationResult ValidarUsuario(string pdesLogin, string pclvContrasenia, string pKeySistema, string numIP)
        {
            BEUsuarioValidoResponse objUsuarioValidado = null;
            SeguridadData           objSeguridadDataNx = null;

            try
            {
                objSeguridadDataNx = new SeguridadData();

                var pUserSeek = ValidarDataAccesoUsuario(pdesLogin, pclvContrasenia);

                if (pUserSeek.brokenRulesCollection.Count == 0)
                {
                    string pMessage = string.Empty;
                    if (!DetectLoginPasswordExterno(pdesLogin, pclvContrasenia, out pMessage))
                    {
                        var operationResult = new OperationResult();
                        operationResult.isValid = false;
                        operationResult.brokenRulesCollection.Add(new BrokenRule
                        {
                            description = pMessage,
                            severity    = RuleSeverity.Warning
                        });

                        return(operationResult);
                    }
                    objUsuarioValidado = objSeguridadDataNx.FindLoginValidated(pdesLogin);

                    if (objUsuarioValidado == null)
                    {
                        /* Guardar auditoria de los ingresos FALLIDOS al sistema  */
                        int codigoRetorno = InsertAuditoria(new BEAuditoria
                        {
                            desLogin       = pdesLogin,
                            codRol         = null,
                            codSistema     = pKeySistema,
                            desMensaje     = WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == 2004).Value,
                            desTipo        = RuleSeverity.Warning.ToString(),
                            fecRegistroApp = DateTime.Now.AddHours(GlobalSettings.GetDEFAULT_HorasFechaActualCloud()),
                            nomMaquinaIP   = numIP
                        });

                        var operationResult = new OperationResult();
                        if (codigoRetorno <= 3)
                        {
                            operationResult.brokenRulesCollection.Add(new BrokenRule
                            {
                                description = WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == 2004).Value,
                                severity    = RuleSeverity.Warning
                            });
                        }
                        else
                        {
                            operationResult.brokenRulesCollection.Add(new BrokenRule
                            {
                                description = string.Format(WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == 2013).Value,
                                                            codigoRetorno),
                                severity = RuleSeverity.Warning
                            });
                        }
                        return(operationResult);
                    }
                    else /* Guardar auditoria de los ingresos SATISFACTORIOS al sistema  */
                    {
                        var operationResult = new OperationResult();
                        operationResult = ValidarAccesoUsuarioSistemaEmpresa(objUsuarioValidado, pKeySistema);

                        if (operationResult.isValid)
                        {
                            objUsuarioValidado.Token           = GetToken(objUsuarioValidado);
                            objUsuarioValidado.ResultIndValido = true;

                            var auditoria = new BEAuditoria
                            {
                                desLogin       = pdesLogin,
                                codRol         = objUsuarioValidado.codRol,
                                codEmpresa     = objUsuarioValidado.codEmpresa,
                                codSistema     = pKeySistema,
                                desTipo        = RuleSeverity.Success.ToString(),
                                fecRegistroApp = DateTime.Now.AddHours(GlobalSettings.GetDEFAULT_HorasFechaActualCloud()),
                                nomMaquinaIP   = numIP
                            };
                            auditoria.desMensaje = WebConstants.ValidacionDatosSEGURIDAD.FirstOrDefault(x => x.Key == 2000).Value;
                            int codigoRetorno = InsertAuditoria(auditoria);
                        }
                        else
                        {
                            return(operationResult);
                        }
                    }
                }
                else
                {
                    objUsuarioValidado = new BEUsuarioValidoResponse();
                    objUsuarioValidado.ResultIMessage  = pUserSeek.brokenRulesCollection[0].description;
                    objUsuarioValidado.ResultIndValido = false;
                }
                return(OK(objUsuarioValidado));
            }
            catch (Exception ex)
            {
                return(Error(GetType().Name, MethodBase.GetCurrentMethod().Name, ex, "", ""));
            }
        }
        private void AccederAlSistema()
        {
            try
            {
                if (CONTADOR_ACCESS > 2)
                {
                    this.FindForm().Close();
                }

                BEUsuarioValidoResponse usuarioValido = null;

                if (GlobalSettings.GetDEFAULT_ServicioWEB())
                {
                    usuarioValido = ApiServiceSeguridad.ValidarInicioSesion(txtLogin.Text,
                                                                            txtPassword.Text,
                                                                            GlobalSettings.GetDEFAULT_KEY_SYSTEM());
                }
                else
                {
                    usuarioValido = oAccesos.DetectLoginPasswordValid(txtLogin.Text,
                                                                      txtPassword.Text,
                                                                      GlobalSettings.GetDEFAULT_KEY_SYSTEM(),
                                                                      HelpWindows.Usuario(true));
                }

                if (usuarioValido != null && usuarioValido.ResultIndValido)
                {
                    BEUsuarioValidoResponse ouserValido = new BEUsuarioValidoResponse();
                    ouserValido = JsonConvert.DeserializeObject <BEUsuarioValidoResponse>(JsonConvert.SerializeObject(usuarioValido));

                    List <BEUsuarioPermisoResponse> lstUsuarioPermisos = new List <BEUsuarioPermisoResponse>();
                    List <BEUsuarioPermisoResponse> lstRolOpcion       = new List <BEUsuarioPermisoResponse>();

                    if (GlobalSettings.GetDEFAULT_ServicioWEB())
                    {
                        var dataPermiso = new BEUsuarioPermisoRequest
                        {
                            codEmpresa = usuarioValido.codEmpresa,
                            codSistema = usuarioValido.codSistema,
                            desLogin   = usuarioValido.desLogin,
                            tipoObjeto = string.Empty,
                            token      = usuarioValido.Token
                        };

                        lstUsuarioPermisos = ApiServiceSeguridad.ListUserObjectGrants(dataPermiso);
                    }
                    else
                    {
                        lstUsuarioPermisos = oAccesos.ListUserObjectsGrants(ouserValido.codEmpresa,
                                                                            ouserValido.codSistema,
                                                                            ouserValido.desLogin,
                                                                            string.Empty,
                                                                            string.Empty);
                    }

                    ouserValido.lstObjeto = lstUsuarioPermisos;

                    lstRolOpcion = ouserValido.lstObjeto.ToList <BEUsuarioPermisoResponse>();

                    ouserValido.codRol                     = ouserValido.codRol;
                    ouserValido.codRolNombre               = ouserValido.codRolNombre;
                    ouserValido.codPersonaEmpresa          = ouserValido.numRUC;
                    ouserValido.codPersonaEmpresaNombre    = ouserValido.codEmpresaNombre;
                    ouserValido.codPersonaEmpresaDomicilio = string.Empty;
                    ouserValido.codPersonaRUCEmpresa       = ouserValido.numRUC;

                    if (ptbLogo.Image != null)
                    {
                        HelpImages.CrearArchivoDesdeBinario(Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
                                                                         "logo.png"),
                                                            HelpImages.DeImagenBD_aBytes(ptbLogo.Image), false);
                    }
                    else
                    if (!File.Exists(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logo.png")))
                    {
                        HelpImages.CrearArchivoDesdeBinario(Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
                                                                         "logo.png"),
                                                            HelpImages.DeImagenBD_aBytes(ResourceIconos.LogoComun), false);
                    }

                    HelpAccesos.SerializarUsuario(ouserValido);

                    this.FindForm().DialogResult = DialogResult.OK;
                    objUsuarioValidado           = ouserValido;
                    lstOpcionPermisos            = lstRolOpcion;

                    Hide();
                }
                else
                {
                    MessageBox.Show(usuarioValido.ResultIMessage, "Verificar Datos!", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    ++CONTADOR_ACCESS;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }