/// <summary>
/// Cria novo objeto HttpClient através do baseAddress e do handler padrão para conexão
/// </summary>
/// <param name="baseAddress">URL do enedereço base para conexão com o serviço REST</param>
/// <param name="token">Toke da sessão - DEVE SER OBTIDO DO Web services de Autenticação</param>
/// <returns>Objeto HttpClient</returns>
public HttpClient CreateHttpClient()
{
try
{
HttpClient client = new HttpClient()
{
Timeout = TimeSpan.FromMinutes(20),
BaseAddress = new Uri(this.BaseAddress),
};
/// Toke da sessão - DEVE SER OBTIDO DO Web services de Autenticação
client.DefaultRequestHeaders.Add("Authorization", this.Token.Set_Token);
client.DefaultRequestHeaders.Add("X-CSRF-Token", this.Token.X_CSRF_Token);
client.DefaultRequestHeaders.Accept
.Add(new MediaTypeWithQualityHeaderValue(this.EdiaType));
return(client);
}
catch (Exception ex)
{
ApplicationException aEx = new ApplicationException(string.Format("Erro ao estabelecer comunicação com o serviço: \'{0}\'.", ex.Message));
GlobalException.ReturnException(aEx);
return(null);
}
}
/// <summary>
/// Retorna objeto do certificado para autenticação no serviço
/// Obtendo o certificado em um caminho físico na maquina/rede
/// </summary>
/// <param name="rootPath">Caminho do diretório raiz do projeto</param>
/// <param name="filename">Nome do certificado a ser lido</param>
/// <param name="password">Senha do certificado para extração</param>
/// <returns>Objeto X509Certificate2 contento o certificado</returns>
public static X509Certificate2 ObterCertificado(string rootPath, string filename, string password)
{
try
{
if (string.IsNullOrEmpty(rootPath))
{
BusinessException bEx = new BusinessException("Caminho do certificado não informado.");
GlobalException.ReturnException(bEx);
}
string filePath = Path.Combine(rootPath, filename);
if (!File.Exists(filePath))
{
BusinessException aEx = new BusinessException(string.Format("Arquivo do certificado inexistente: \'{0}\'.", filename));
GlobalException.ReturnException(aEx);
}
X509Certificate2 certificate = new X509Certificate2(filePath, password, X509KeyStorageFlags.MachineKeySet);
return(certificate);
}
catch (Exception ex)
{
ApplicationException bEx = new ApplicationException("Erro ao extrair certificado: " + ex.Message);
GlobalException.ReturnException(bEx);
return(null);
}
}
// <summary>
/// Alterar Jogo
/// </summary>
/// <param name="Jogo">Jogo</param>
/// <returns></returns>
public void Alterar(Jogo model)
{
try
{
_jogoRepository.Update(model);
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
}
}
// <summary>
/// Excluir Jogo
/// </summary>
/// <param name="Jogo">Jogo</param>
/// <returns></returns>
public void Excluir(Jogo model)
{
try
{
_jogoRepository.Remove(model);
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
}
}
/// <summary>
/// Listar Jogos
/// </summary>
/// <returns></returns>
public List <Jogo> Listar()
{
try
{
return(_jogoRepository.Listar());
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
return(new List <Jogo>());
}
}
/// <summary>
/// Logar
/// </summary>
/// <param name="UsuarioVM">UsuarioVM</param>
/// <returns></returns>
public Usuario Login(UsuarioVM model)
{
try
{
return(_Db.Usuario.FirstOrDefault(x => x.Nome.ToUpper().Trim() == model.Nome.ToUpper().Trim() && x.Senha.ToUpper().Trim() == model.Senha.ToUpper().Trim()));
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
return(new Usuario());
}
}
// <summary>
/// Cadastrar Amigo
/// </summary>
/// <param name="AmigoVM">AmigoVM</param>
/// <returns></returns>
public void Cadastrar(AmigoVM model)
{
try
{
Amigo amigo = new Amigo()
{
Nome = model.Nome
};
_amigoRepository.Add(amigo);
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
}
}
// <summary>
/// Cadastrar Usuario
/// </summary>
/// <param name="UsuarioVM">UsuarioVM</param>
/// <returns></returns>
public void Cadastrar(UsuarioVM model)
{
try
{
Usuario usuario = new Usuario()
{
Nome = model.Nome,
Senha = model.Senha
};
_usuarioRepository.Add(usuario);
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
}
}
// <summary>
/// Cadastrar Jogo
/// </summary>
/// <param name="JogoVM">JogoVM</param>
/// <returns></returns>
public void Cadastrar(JogoVM model)
{
try
{
Jogo jogo = new Jogo()
{
Nome = model.Nome,
AmigoID = model.AmigoId
};
_jogoRepository.Add(jogo);
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
}
}
/// <summary>
/// Retorna objeto do certificado para autenticação no serviço
/// Obtendo o certificado registrado no repositório local do usuário do SO
/// </summary>
/// <returns>Objeto X509Certificate2 contento o certificado</returns>
public static X509Certificate2 ObterCertificado(string CertificadoDigitalECPF)
{
X509Store store = new X509Store("MY", StoreLocation.CurrentUser);
try
{
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate2Collection collection = (X509Certificate2Collection)store.Certificates;
X509Certificate2Collection fcollection = (X509Certificate2Collection)collection.Find(X509FindType.FindByTimeValid, DateTime.Now, false);
foreach (X509Certificate2 x509 in fcollection)
{
try
{
if (x509.FriendlyName.IndexOf(CertificadoDigitalECPF) != -1)
{
//Console.WriteLine(x509.FriendlyName);
return(x509);
}
//Console.WriteLine(x509.FriendlyName);
}
catch (CryptographicException)
{
CryptographicException cEx = new CryptographicException("As informações não puderam ser obtidas deste certificado.");
GlobalException.ReturnException(cEx);
}
}
BusinessException bEx = new BusinessException("Certificado não localizado.");
GlobalException.ReturnException(bEx);
return(null);
}
catch (Exception ex)
{
ApplicationException aEx = new ApplicationException(string.Format("Erro ao extrair certificado: \'{0}\'.", ex.Message));
GlobalException.ReturnException(aEx);
return(null);
}
finally
{
store.Close();
}
}
// <summary>
/// Excluir Amigo
/// </summary>
/// <param name="Amigo">Amigo</param>
/// <returns></returns>
public void Excluir(Amigo model)
{
try
{
List <Jogo> listaJogos = _jogoRepository.PesquisarPorAmigo(model.Id);
if (listaJogos.Any())
{
throw new BusinessException("Existem jogos empretados para esse amigo");
}
_amigoRepository.Remove(model);
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
}
}
/// <summary>
/// Envia uma requisição POST para o endpoint formado por baseAddress e url
/// </summary>
/// <param name="url">Action usada para criar resource no serviço</param>
/// <returns>Resultado da requisição</returns>
public async Task <JRetornoAutenticacao> Post(string url)
{
JRetornoAutenticacao retorno = null;
try
{
HttpResponseMessage response = null;
if (this.HoraExpiracaoToken <= DateTime.Now || string.IsNullOrWhiteSpace(this.Token))
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url);
response = this.HttpClient.SendAsync(request).Result;
if ((int)response.StatusCode != 200)
{
ApplicationException aEx = new ApplicationException(response.ReasonPhrase);
GlobalException.ReturnException(aEx);
}
this.HoraExpiracaoToken = DateTime.Now.AddMinutes(this.ValidadeTokenMinutos);
string operationLocation = response.Headers.GetValues("Set-Token").FirstOrDefault();
retorno = new JRetornoAutenticacao
{
Set_Token = response.Headers.GetValues("Set-Token").FirstOrDefault(),
X_CSRF_Expiration = response.Headers.GetValues("X-CSRF-Expiration").FirstOrDefault(),
X_CSRF_Token = response.Headers.GetValues("X-CSRF-Token").FirstOrDefault()
};
}
return(retorno);
}
catch (Exception ex)
{
ApplicationException aEx = new ApplicationException(string.Format("Erro ao enviar requisição para serviço: \'{0}\'.", ex.Message));
GlobalException.ReturnException(aEx);
return(null);
}
}
/// <summary>
/// Envia uma requisição POST para o endpoint formado por baseAddress e url, usando
/// como request body o parâmetro jsonData
/// </summary>
/// <param name="url">Action usada para criar resource no serviço</param>
/// <param name="jsonData">Objeto usado para requisição</param>
/// <returns>Resultado da requisição</returns>
public async Task <HttpResponseMessage> Post(string url, string jsonData, string ediaType = "application/json")
{
try
{
HttpResponseMessage response = null;
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new StringContent(jsonData, Encoding.UTF8, ediaType),
};
response = this.HttpClient.SendAsync(request).Result;
return(response);
}
catch (Exception ex)
{
ApplicationException aEx = new ApplicationException(string.Format("Erro ao enviar requisição para serviço: \'{0}\'.", ex.Message));
GlobalException.ReturnException(aEx);
return(null);
}
}
/// <summary>
/// Logar
/// </summary>
/// <param name="UsuarioVM">UsuarioVM</param>
/// <returns></returns>
public UsuarioVM Login(UsuarioVM model)
{
try
{
Usuario usu = _usuarioRepository.Login(model);
if (usu == null)
{
throw new BusinessException("Credenciais inválidas.");
}
TokenService ts = new TokenService();
var token = ts.GenerateToken(usu);
model.Token = token;
return(model);
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
return(new UsuarioVM());
}
}
public string ComunicarEntregaDocumentoCarga(EntregasDocumentoCarga entregasDocumentoCarga)
{
/// EndPoint
string lEndPoint = URLBase + Util.ObterParametro <string>("PUCOMEX.EndPointComunicarEntregaDocumentoCarga");
RestClient client = new RestClient(lEndPoint, Autenticar(), "application/xml");
string text = Util.Serializar <EntregasDocumentoCarga>(entregasDocumentoCarga, "http://www.pucomex.serpro.gov.br/cct"); //##// Buscar de parametro NameSpace do XML da integração PUCOMEX
using (client)
{
HttpResponseMessage response = client.Post(lEndPoint, text, "application/xml").Result;
int StatusCode = (int)response.StatusCode;
if (!StatusCode.Equals(200))
{
BusinessException ex = new BusinessException(response.Content.ReadAsStringAsync().Result);
GlobalException.ReturnException(ex);
}
return(response.Content.ReadAsStringAsync().Result);
}
}
/// <summary>
/// Configura o handler para o HttpClient, usando certificado e protocolos SSL
/// </summary>
/// <returns>Objeto HttpClientHandler para configurar conexão http</returns>
private HttpClientHandler GetHttpClientHandler()
{
try
{
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls | SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11;
HttpClientHandler handler = new HttpClientHandler
{
MaxConnectionsPerServer = 9999,
//SslProtocols = SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12
};
/// Obtendo o certificado em um caminho físico na maquina/rede
X509Certificate2 certificate = Certificate.ObterCertificado(ROOTPATH, CERTFILE, PASSWORD);
/// Obtendo o certificado registrado no repositório local do usuário no SO
//X509Certificate2 certificate = Certificate.ObterCertificado(Certificado_Digital);
_ = handler.ClientCertificates.Add(certificate);
handler.ServerCertificateCustomValidationCallback += (sender, cert, chain, errors) =>
{
//if (Config.LerConfiguracao("AmbDEV").Equals("1"))
return(true); // No ambiente de Desenvolvimento, trust all certificates
//return errors == SslPolicyErrors.None; // Compliant: trust only some certificates
};
return(handler);
}
catch (Exception ex)
{
ApplicationException aEx = new ApplicationException(ex.Message);
GlobalException.ReturnException(aEx);
return(null);
}
}
/// <summary>
/// Cria novo objeto HttpClient através do baseAddress e do handler padrão para conexão
/// </summary>
/// <param name="baseAddress">URL do enedereço base para conexão com o serviço REST</param>
/// <returns>Objeto HttpClient</returns>
public void CreateHttpClient(string baseAddress)
{
try
{
HttpClientHandler handler = this.GetHttpClientHandler();
HttpClient client = new HttpClient(handler)
{
Timeout = TimeSpan.FromMinutes(1),
BaseAddress = new Uri(baseAddress),
};
client.DefaultRequestHeaders.Add("Role-Type", "DEPOSIT");
client.DefaultRequestHeaders.Accept
.Add(new MediaTypeWithQualityHeaderValue("application/json"));
this.HttpClient = client;
}
catch (Exception ex)
{
ApplicationException aEx = new ApplicationException(string.Format("Erro ao estabelecer comunicação com o serviço: \'{0}\'.", ex.Message));
GlobalException.ReturnException(aEx);
}
}
public override int SaveChanges()
{
try
{
var added = new List <KeyValuePair <object, LogMeusJogos> >();
var entries = ChangeTracker.Entries().Where(x => x.State == EntityState.Added || x.State == EntityState.Modified || x.State == EntityState.Deleted).ToList();
foreach (var dbEntityEntry in entries)
{
var entityName = dbEntityEntry.Entity.GetType().Name;
var primaryKey = GetPrimaryKeyValue(dbEntityEntry);
switch (dbEntityEntry.State)
{
case EntityState.Added:
case EntityState.Deleted:
var log = new LogMeusJogos
{
Tabela = entityName,
Acao = dbEntityEntry.State.ToString(),
MatriculaUsuario = (_accessor?.HttpContext?.User?.Identity?.Name != null) ? int.Parse(_accessor.HttpContext.User.Identity.Name) : 0,
Chaves = primaryKey,
NomeColuna = "*",
Propriedade = "*",
ValorOriginal = String.Empty,
ValorAtual = String.Empty,
DtcOcorrencia = DateTime.Now
};
if (dbEntityEntry.State == EntityState.Deleted)
{
log.ValorOriginal = JsonConvert.SerializeObject(dbEntityEntry.Entity);
}
Set <LogMeusJogos>().Add(log);
if (dbEntityEntry.State != EntityState.Added)
{
continue;
}
var kv = new KeyValuePair <object, LogMeusJogos>(dbEntityEntry.Entity, log);
added.Add(kv);
break;
case EntityState.Modified:
GeraLogUpdate(dbEntityEntry, entityName, primaryKey);
break;
}
}
var result = base.SaveChanges();
UpdateInsertedKey(added);
return(result);
}
catch (Exception ex)
{
GlobalException.ReturnException(ex);
return(0);
}
}
