private void AddSAMLCookie()
{
if (!string.IsNullOrEmpty(SAMLRequest.AssertionConsumerServiceURL))
{
HttpCookie cookie = Request.Cookies["SistemasLogged"];
if (cookie == null)
{
cookie = new HttpCookie("SistemasLogged");
Response.Cookies.Add(cookie);
}
// Carrega a Entidade SYS_Sistema apartir do caminho de login
SYS_Sistema entitySistema = new SYS_Sistema {
sis_caminho = SAMLRequest.AssertionConsumerServiceURL
};
if (SYS_SistemaBO.GetSelectBy_sis_caminho(entitySistema, SYS_SistemaBO.TypePath.login))
{
// Armazena sistema no Cookie
cookie.Values[entitySistema.sis_id.ToString()] = entitySistema.sis_id.ToString();
// Atualiza dados do Cookie
Response.Cookies.Set(cookie);
}
else
{
throw new ValidationException("Não foi possível atender a solicitação, sistema emissor da requisição não está cadastrado corretamente.");
}
}
else
{
throw new ValidationException("Não foi possível atender a solicitação, requisição inválida.");
}
}
private void RedirecionarLogin(Guid usu_id)
{
string caminhoRedirecionar = String.Concat(ApplicationWEB._DiretorioVirtual, "Sistema.aspx");
if (GetSistemaID_QueryString > 0)
{
__SessionWEB.SistemaID_QueryString = GetSistemaID_QueryString;
}
if (__SessionWEB.SistemaID_QueryString > 0)
{
List <SYS_Sistema> listaSistemaPermissao = new List <SYS_Sistema>(SYS_SistemaBO.GetSelectBy_usu_id(usu_id));
if (listaSistemaPermissao.Exists(p => p.sis_id == __SessionWEB.SistemaID_QueryString))
{
SYS_Sistema sistema = new SYS_Sistema {
sis_id = __SessionWEB.SistemaID_QueryString
};
SYS_SistemaBO.GetEntity(sistema);
if (!sistema.IsNew)
{
caminhoRedirecionar = sistema.sis_caminho;
}
}
}
Response.Redirect(caminhoRedirecionar, false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
}
/// <summary>
/// Configura a Session com os dados do sistema
/// </summary>
protected void LoadSessionSistema()
{
// Armazena o nome do sistema atual na Session
SYS_Sistema entitySistema = new SYS_Sistema {
sis_id = ApplicationWEB.SistemaID
};
SYS_SistemaBO.GetEntity(entitySistema);
__SessionWEB.TituloSistema = entitySistema.sis_nome;
// Armazena o caminho do logo do sistema atual
__SessionWEB.UrlLogoSistema = __SessionWEB.LogoImagemCaminho + entitySistema.sis_urlLogoCabecalho;
// Armazena caminho do logo e url do cliente na entidade logada (se existir)
SYS_SistemaEntidade entitySistemaEntidade = new SYS_SistemaEntidade {
sis_id = ApplicationWEB.SistemaID, ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id
};
SYS_SistemaEntidadeBO.GetEntity(entitySistemaEntidade);
if (!string.IsNullOrEmpty(entitySistemaEntidade.sen_urlCliente))
{
__SessionWEB.UrlInstituicao = entitySistemaEntidade.sen_urlCliente;
}
if (!string.IsNullOrEmpty(entitySistemaEntidade.sen_logoCliente))
{
__SessionWEB.UrlLogoInstituicao = __SessionWEB.LogoImagemCaminho + entitySistemaEntidade.sen_logoCliente;
}
else
{
__SessionWEB.UrlLogoInstituicao = __SessionWEB.LogoImagemCaminho + "LOGO_CLIENTE.png";
}
}
public IList <SYS_Sistema> SelectBy_usu_id(Guid usu_id)
{
List <SYS_Sistema> lt = new List <SYS_Sistema>();
QuerySelectStoredProcedure qs = new QuerySelectStoredProcedure("NEW_SYS_Sistema_SELECTBY_usu_id", _Banco);
try
{
#region PARAMETROS
Param = qs.NewParameter();
Param.DbType = DbType.Guid;
Param.ParameterName = "@usu_id";
Param.Size = 16;
Param.Value = usu_id;
qs.Parameters.Add(Param);
#endregion
qs.Execute();
foreach (DataRow dr in qs.Return.Rows)
{
SYS_Sistema entity = new SYS_Sistema();
lt.Add(DataRowToEntity(dr, entity));
}
return(lt);
}
catch
{
throw;
}
}
private void _Carregar_dados()
{
try
{
SYS_Sistema sistemas = new SYS_Sistema {
sis_id = _VS_sis_id
};
SYS_SistemaBO.GetEntity(sistemas);
_VS_SistemaEntidade = SYS_SistemaEntidadeBO.SelectEntidade(_VS_sis_id, false, 1, 1);
_VS_sis_id = sistemas.sis_id;
_txtsisnome.Text = sistemas.sis_nome;
_txtsiscaminho.Text = sistemas.sis_caminho;
_txtsiscaminhoLogout.Text = sistemas.sis_caminhoLogout;
_txtsisDescricao.Text = sistemas.sis_descricao;
_txturlintegracao.Text = sistemas.sis_urlIntegracao;
_ckbOcultaLogo.Checked = sistemas.sis_ocultarLogo;
if (_VS_SistemaEntidade.Rows.Count <= 0)
{
_VS_SistemaEntidade = null;
}
string caminhoBDImagem = Server.MapPath(caminhoLogos + sistemas.sis_urlImagem);
if (File.Exists(caminhoBDImagem))
{
imgImagemSistema.Visible = true;
imgImagemSistema.ImageUrl = caminhoLogos + sistemas.sis_urlImagem;
}
else
{
imgImagemSistema.Visible = false;
}
caminhoBDImagem = Server.MapPath(caminhoLogos + sistemas.sis_urlLogoCabecalho);
if (File.Exists(caminhoBDImagem))
{
imgLogoCabecalho.Visible = true;
imgLogoCabecalho.ImageUrl = caminhoLogos + sistemas.sis_urlLogoCabecalho;
}
else
{
imgLogoCabecalho.Visible = false;
}
_dgvSistemaEntidade.DataSource = _VS_SistemaEntidade;
_dgvSistemaEntidade.DataBind();
_uppGridSistemaEntidade.Update();
_uppCadastroSistema.Update();
}
catch (Exception e)
{
ApplicationWEB._GravaErro(e);
_lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar o sistema.", UtilBO.TipoMensagem.Erro);
_uppCadastroSistema.Update();
}
}
private void CreateSAMLResponse()
{
IDProvider config = IDProvider.GetConfig();
SAMLResponse.ID = SAMLUtility.GenerateID();
SAMLResponse.Version = SAMLUtility.VERSION;
SAMLResponse.IssueInstant = DateTime.UtcNow.AddMinutes(10);
SAMLResponse.InResponseTo = SAMLRequest.ID;
SAMLResponse.Issuer = new NameIDType();
SAMLResponse.Issuer.Value = config.id;
SAMLResponse.Status = new StatusType();
SAMLResponse.Status.StatusCode = new StatusCodeType();
// Atualiza Cookie de sistemas autenticados e configura Status
HttpCookie cookie = this.Context.Request.Cookies["SistemasLogged"];
if (cookie != null)
{
// Carrega a Entidade SYS_Sistema apartir do caminho de logout
SYS_Sistema entitySistema = new SYS_Sistema {
sis_caminhoLogout = ((NameIDType)SAMLRequest.Item).Value
};
if (SYS_SistemaBO.GetSelectBy_sis_caminho(entitySistema, SYS_SistemaBO.TypePath.logout))
{
// Remove o sistema do Cookie
cookie.Values.Remove(entitySistema.sis_id.ToString());
// Atualiza dados do Cookie
this.Context.Response.Cookies.Set(cookie);
if (!cookie.Values.AllKeys.Contains(entitySistema.sis_id.ToString()))
{
SAMLResponse.Status.StatusCode.Value = SAMLUtility.StatusCodes.Success;
SAMLResponse.Status.StatusMessage = "A solicitação foi realizada com sucesso.";
}
else
{
SAMLResponse.Status.StatusCode.Value = SAMLUtility.StatusCodes.RequestDenied;
SAMLResponse.Status.StatusMessage = "Não foi possível atender a solicitação, o sistema emissor da requisição não está autenticado.";
}
}
else
{
SAMLResponse.Status.StatusCode.Value = SAMLUtility.StatusCodes.RequestDenied;
SAMLResponse.Status.StatusMessage = "Não foi possível atender a solicitação, sistema emissor da requisição não está cadastrado corretamente.";;
}
}
else
{
SAMLResponse.Status.StatusCode.Value = SAMLUtility.StatusCodes.RequestDenied;
SAMLResponse.Status.StatusMessage = "Não foi possível atender a solicitação.";
}
HttpPostBinding binding = new HttpPostBinding(SAMLResponse, HttpUtility.UrlDecode(this.Context.Request[HttpBindingConstants.RelayState]));
binding.SendResponse(this.Context, HttpUtility.UrlDecode(this.Context.Request[HttpBindingConstants.RelayState]), SAMLTypeSSO.logout);
}
private void _Salvar()
{
try
{
SYS_Sistema entsis = new SYS_Sistema {
sis_id = _VS_sis_id
};
SYS_SistemaBO.GetEntity(entsis);
entsis.sis_nome = _txtsisnome.Text;
entsis.sis_caminho = _txtsiscaminho.Text;
entsis.sis_caminhoLogout = _txtsiscaminhoLogout.Text;
entsis.sis_descricao = _txtsisDescricao.Text;
entsis.sis_urlIntegracao = _txturlintegracao.Text;
entsis.sis_ocultarLogo = _ckbOcultaLogo.Checked;
entsis.IsNew = false;
if (!string.IsNullOrEmpty(fupImagemSistema.FileName))
{
entsis.sis_urlImagem = NomeLogoImagemMenu;
SalvaImagem(fupImagemSistema, NomeLogoImagemMenu, tamanhoMaxBytes);
}
List <SYS_SistemaEntidade> _List_Entities_SistemEntidade = SYS_SistemaEntidadeBO.CriaList_Entities_SistemaEntidade(_VS_SistemaEntidade);
if (!string.IsNullOrEmpty(fupLogoCabecalho.FileName))
{
entsis.sis_urlLogoCabecalho = NomeLogoCabecalho;
SalvaImagem(fupLogoCabecalho, NomeLogoCabecalho, tamanhoMaxBytes);
}
if (SYS_SistemaBO.SalvarUrlInte(entsis, _List_Entities_SistemEntidade))
{
ApplicationWEB._GravaLogSistema(LOG_SistemaTipo.Update, "sis_id:" + entsis.sis_id);
__SessionWEB.PostMessages = UtilBO.GetErroMessage("Sistema salvo com sucesso.", UtilBO.TipoMensagem.Sucesso);
Response.Redirect(__SessionWEB._AreaAtual._Diretorio + "Sistemas/Busca.aspx", false);
}
else
{
_lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o sistema.", UtilBO.TipoMensagem.Erro);
}
}
catch (ValidationException e)
{
_lblMessage.Text = UtilBO.GetErroMessage(e.Message, UtilBO.TipoMensagem.Alerta);
}
catch (Exception e)
{
ApplicationWEB._GravaErro(e);
_lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar salvar o sistema.", UtilBO.TipoMensagem.Erro);
}
finally
{
_uppCadastroSistema.Update();
}
}
/// <summary>
/// Atribui o sis_id que efetuou o logout à session, caso o login seja feito diretamente através da query string
/// </summary>
/// <param name="caminhoLogout">Caminho de logout do sistema que efetuou a solicitação</param>
private void AtribuirSessionSisIDLogout(string caminhoLogout)
{
if (__SessionWEB.SistemaID_QueryString > 0 && __SessionWEB.SistemaIDLogout_QueryString <= 0)
{
SYS_Sistema sistemaLogout = new SYS_Sistema {
sis_caminhoLogout = caminhoLogout
};
SYS_SistemaBO.GetSelectBy_sis_caminho(sistemaLogout, SYS_SistemaBO.TypePath.logout);
__SessionWEB.SistemaIDLogout_QueryString = sistemaLogout.sis_id;
}
}
/// <summary>
/// Carrega sistema apartir do caminho de login
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public bool SelectBy_sis_caminho(SYS_Sistema entity)
{
QuerySelectStoredProcedure qs = new QuerySelectStoredProcedure("NEW_SYS_Sistema_SELECTBY_sis_caminho", _Banco);
try
{
#region PARAMETROS
Param = qs.NewParameter();
Param.DbType = DbType.AnsiString;
Param.ParameterName = "@sis_caminho";
Param.Size = 2000;
if (!string.IsNullOrEmpty(entity.sis_caminho))
{
Param.Value = entity.sis_caminho;
}
else
{
throw new ArgumentNullException("entity", "O parâmetro entity.sis_caminho não pode ser vázio ou nulo.");
}
qs.Parameters.Add(Param);
#endregion
qs.Execute();
if (qs.Return.Rows.Count > 0)
{
entity = DataRowToEntity(qs.Return.Rows[0], entity, false);
return(true);
}
return(false);
}
catch
{
throw;
}
finally
{
qs.Parameters.Clear();
}
}
private static IList <Claim> GetClaims(SYS_Usuario usuarioCore, SYS_Grupo entityGrupo = null)
{
string roles = "";
string grupoId = null;
if (entityGrupo != null)
{
SYS_Sistema entitySistema = new SYS_Sistema
{
sis_id = entityGrupo.sis_id
};
grupoId = entityGrupo.gru_id.ToString();
SYS_SistemaBO.GetEntity(entitySistema);
if (entitySistema.sis_tipoAutenticacao == 1)
{
SYS_Visao entityVisao = new SYS_Visao
{
vis_id = entityGrupo.vis_id
};
SYS_VisaoBO.GetEntity(entityVisao);
roles = entityVisao.vis_nome;
}
}
string name = FormatarUserNameDoCookie(usuarioCore.ent_id.ToString(), usuarioCore.usu_login, grupoId);
var claims = new List <Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, usuarioCore.usu_id.ToString()));
claims.Add(new Claim(ClaimTypes.Name, name));
claims.Add(new Claim(ClaimTypes.Email, usuarioCore.usu_email ?? string.Empty));
claims.Add(new Claim(ClaimTypes.Role, roles));
claims.Add(new Claim(AutenticadorCustomClaimTypes.EntidadeId, usuarioCore.ent_id.ToString()));
claims.Add(new Claim(AutenticadorCustomClaimTypes.GrupoId, grupoId ?? string.Empty));
return(claims);
}
/// <summary>
/// Atualiza o campo de auditoria nos modulos
/// </summary>
/// <returns>True: ocorreu alguma alteração / False: não ocorreu nenhuma alteração </returns>
public bool UpdateUrlInte
(
SYS_Sistema sistema
)
{
int totalRecords;
QuerySelectStoredProcedure ques = new QuerySelectStoredProcedure("NEW_SYS_Sistema_UPDATE_UrlIntegracao", _Banco);
try
{
#region PARAMETROS
Param = ques.NewParameter();
Param.DbType = DbType.Int32;
Param.ParameterName = "@sis_id";
Param.Size = 4;
if (sistema.sis_id > 0)
{
Param.Value = sistema.sis_id;
}
else
{
Param.Value = DBNull.Value;
}
ques.Parameters.Add(Param);
Param = ques.NewParameter();
Param.DbType = DbType.AnsiString;
Param.ParameterName = "@sis_caminho";
Param.Size = 100;
if (!string.IsNullOrEmpty(sistema.sis_caminho))
{
Param.Value = sistema.sis_caminho;
}
else
{
Param.Value = DBNull.Value;
}
ques.Parameters.Add(Param);
Param = ques.NewParameter();
Param.DbType = DbType.AnsiString;
Param.ParameterName = "@sis_urlIntegracao";
Param.Size = 200;
if (!string.IsNullOrEmpty(sistema.sis_urlIntegracao))
{
Param.Value = sistema.sis_urlIntegracao;
}
else
{
Param.Value = DBNull.Value;
}
ques.Parameters.Add(Param);
#endregion
ques.Execute();
totalRecords = ques.Return.Rows.Count;
if (totalRecords > 0)
{
return(true);
}
else
{
return(false);
}
}
catch
{
throw;
}
finally
{
ques.Parameters.Clear();
}
}
public new void ProcessRequest(HttpContext context)
{
try
{
// ***** REQUEST *****
if (!String.IsNullOrEmpty(context.Request[HttpBindingConstants.SAMLRequest]))
{
// Recupera LogoutRequest
StringBuilder result = new StringBuilder();
byte[] encoded = Convert.FromBase64String(HttpUtility.UrlDecode(context.Request[HttpBindingConstants.SAMLRequest]).Replace(" ", "+"));
MemoryStream memoryStream = new MemoryStream(encoded);
using (DeflateStream stream = new DeflateStream(memoryStream, CompressionMode.Decompress))
{
StreamReader reader = new StreamReader(new BufferedStream(stream), Encoding.GetEncoding("iso-8859-1"));
reader.Peek();
result.Append(reader.ReadToEnd());
stream.Close();
}
SAMLRequest = SAMLUtility.DeserializeFromXmlString <LogoutRequestType>(result.ToString());
AtribuirSessionSisIDLogout(((NameIDType)SAMLRequest.Item).Value);
// Criação e configuração LogoutResponse
SAMLResponse = new ResponseType();
CreateSAMLResponse();
}
// ***** RESPONSE *****
else if (!String.IsNullOrEmpty(context.Request[HttpBindingConstants.SAMLResponse]))
{
throw new NotImplementedException();
}
else
{
AtribuirSessionSisIDLogout(String.Concat(ApplicationWEB._DiretorioVirtual, "Logout.ashx"));
__SessionWEB.SistemasRequestLogout++;
//Se existir link de retorno na primeira vez, significa que o sistema que iniciou o processo de logout
//enviou na queryString o endereço que deve ser redirecionado após terminar todo o processo.
if (!String.IsNullOrEmpty(context.Request["SistemaUrlLogout"]) && __SessionWEB.SistemasRequestLogout == 1)
{
__SessionWEB.SistemaUrlLogout_QueryString = context.Request["SistemaUrlLogout"];
}
// Verifica se existe sistemas autenticados em Cookie para realizar logout
HttpCookie cookie = context.Request.Cookies["SistemasLogged"];
if (cookie != null &&
cookie.Values.AllKeys.Count(p => p != null) > 0)
{
SYS_Sistema entitySistema = SYS_SistemaBO.GetEntity(new SYS_Sistema {
sis_id = Convert.ToInt32(cookie.Values.AllKeys.First())
});
HttpContext.Current.Response.Redirect(entitySistema.sis_caminhoLogout, false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
}
else
{
HttpCookie cookieBH = context.Request.Cookies["BH"];
if (cookieBH != null &&
!String.IsNullOrEmpty(IdentitySettingsConfig.IDSSettings.LogoutUrlAVA))
{
HttpContext.Current.Response.Redirect(IdentitySettingsConfig.IDSSettings.LogoutUrlAVA, false);
HttpContext.Current.ApplicationInstance.CompleteRequest();
}
else
{
RedirecionarParaLogoutIdentityServer(context);
}
}
}
}
catch (ValidationException ex)
{
ApplicationWEB._GravaErro(ex);
//ErrorMessage(ex.Message);
RedirecionarParaLogoutIdentityServer(context);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
//ErrorMessage("Não foi possível atender a solicitação.");
RedirecionarParaLogoutIdentityServer(context);
}
}
/// <summary>
/// Grava log de sistema no banco de dados.
/// </summary>
/// <param name="acao">Ação executada pelo usuário</param>
/// <param name="descricao">Descrição do log</param>
/// <param name="usu_login">Login do usuário que tentou realizar a operação (utilizado para operações de login sem sucesso)</param>
/// <returns>Informa se o log de sistema foi salvo com sucesso.</returns>
public static Guid _GravaLogSistema(LOG_SistemaTipo acao, string descricao)
{
try
{
LOG_Sistema entity = new LOG_Sistema();
entity.log_acao = Enum.GetName(typeof(LOG_SistemaTipo), acao);
entity.log_dataHora = DateTime.Now;
entity.log_descricao = descricao;
if (HttpContext.Current != null)
{
//Preenche dados do host do site
LOG_SistemaBO.GenerateLogID();
entity.log_id = new Guid(HttpContext.Current.Session[LOG_Sistema.SessionName].ToString());
entity.log_ip = HttpContext.Current.Request.UserHostAddress;
entity.log_machineName = HttpContext.Current.Server.MachineName;
if (HttpContext.Current.Session != null)
{
SessionWEB session = (SessionWEB)HttpContext.Current.Session[SessSessionWEB];
if (session != null)
{
//Preenche dados referente ao usuário
if (session.__UsuarioWEB != null && session.__UsuarioWEB.Usuario != null)
{
entity.usu_id = session.__UsuarioWEB.Usuario.usu_id;
entity.usu_login = session.__UsuarioWEB.Usuario.usu_login;
}
//Preenche dados referente ao grupo do usuário
if (session.__UsuarioWEB != null && session.__UsuarioWEB.Grupo != null)
{
//Preenche os dados do grupo
entity.gru_id = session.__UsuarioWEB.Grupo.gru_id;
entity.gru_nome = session.__UsuarioWEB.Grupo.gru_nome;
//Preenche os dados do sistema
SYS_Sistema sistema = new SYS_Sistema
{
sis_id = session.__UsuarioWEB.Grupo.sis_id
};
SYS_SistemaBO.GetEntity(sistema);
entity.sis_id = sistema.sis_id;
entity.sis_nome = sistema.sis_nome;
//Preenche os dados do módulo
if (HttpContext.Current.Session[SYS_Modulo.SessionName] != null)
{
SYS_Modulo modulo = (SYS_Modulo)HttpContext.Current.Session[SYS_Modulo.SessionName];
entity.mod_id = modulo.mod_id;
entity.mod_nome = modulo.mod_nome;
}
else
{
entity.mod_id = 0;
entity.mod_nome = string.Empty;
}
//Preenche as entidades e unidades administrativa do grupo
if (session.__UsuarioWEB.GrupoUA != null)
{
//Formata a entidade no padrão JSON
JavaScriptSerializer oSerializer = new JavaScriptSerializer();
entity.log_grupoUA = oSerializer.Serialize(session.__UsuarioWEB.GrupoUA);
}
}
}
}
}
if (!LOG_SistemaBO.Save(entity))
{
throw new Exception("Não foi possível salvar o log do sistema.");
}
if (HttpContext.Current != null)
{
HttpContext.Current.Session[LOG_Sistema.SessionName] = null;
}
return(entity.log_id);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Salva log de erro no banco de dados.
/// Em caso de exceção salva em arquivo teste
/// na pasta Log da raiz do site.
/// </summary>
/// <param name="ex">Exception</param>
public new static void _GravaErro(Exception ex)
{
try
{
string path = String.Concat(_DiretorioFisico, "Log");
LogError logError = new LogError(path);
//Liga o método no delegate para salvar log no banco de dados.
logError.SaveLogBD = delegate(string message)
{
LOG_Erros entity = new LOG_Erros();
try
{
//Preenche a entidade com os dados necessário
entity.err_descricao = message;
entity.err_erroBase = ex.GetBaseException().Message;
entity.err_tipoErro = ex.GetBaseException().GetType().FullName;
entity.err_dataHora = DateTime.Now;
if (HttpContext.Current != null)
{
string infoRequest = "";
try
{
string naoGravar = SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.LOG_ERROS_CHAVES_NAO_GRAVAR);
List <string> listaNaoGravar = new List <string>(naoGravar.Split(';'));
bool gravarQueryString;
Boolean.TryParse(SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.LOG_ERROS_GRAVAR_QUERYSTRING), out gravarQueryString);
if (gravarQueryString)
{
infoRequest += retornaListaColecao(HttpContext.Current.Request.QueryString, "QueryString", listaNaoGravar);
}
bool gravarServerVariables;
Boolean.TryParse(SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.LOG_ERROS_GRAVAR_SERVERVARIABLES), out gravarServerVariables);
if (gravarServerVariables)
{
infoRequest += retornaListaColecao(HttpContext.Current.Request.ServerVariables, "ServerVariables", listaNaoGravar);
}
bool gravarParams;
Boolean.TryParse(SYS_ParametroBO.ParametroValor(SYS_ParametroBO.eChave.LOG_ERROS_GRAVAR_PARAMS), out gravarParams);
if (gravarParams)
{
infoRequest += retornaListaColecao(HttpContext.Current.Request.Params, "Params", listaNaoGravar);
}
}
catch
{
}
entity.err_descricao = entity.err_descricao + infoRequest;
entity.err_ip = HttpContext.Current.Request.UserHostAddress;
entity.err_machineName = HttpContext.Current.Server.MachineName;
entity.err_caminhoArq = HttpContext.Current.Request.AppRelativeCurrentExecutionFilePath;
try
{
entity.err_browser = String.Concat(new[] { HttpContext.Current.Request.Browser.Browser, HttpContext.Current.Request.Browser.MajorVersion.ToString(), HttpContext.Current.Request.Browser.MinorVersionString });
}
catch
{
entity.err_browser = string.Empty;
}
if (HttpContext.Current.Session != null)
{
SessionWEB session = (SessionWEB)HttpContext.Current.Session[SessSessionWEB];
if (session != null)
{
if (session.__UsuarioWEB.Usuario != null)
{
entity.usu_id = session.__UsuarioWEB.Usuario.usu_id;
entity.usu_login = session.__UsuarioWEB.Usuario.usu_login;
}
if (session.__UsuarioWEB.Grupo != null)
{
SYS_Sistema sistema = new SYS_Sistema
{
sis_id = session.__UsuarioWEB.Grupo.sis_id
};
SYS_SistemaBO.GetEntity(sistema);
entity.sis_id = sistema.sis_id;
entity.sis_decricao = sistema.sis_nome;
}
}
}
}
//Salva o log no banco de dados
LOG_ErrosBO.Save(entity);
}
catch (Exception)
{
throw;
}
};
logError.Log(ex, true);
}
catch { }
}
