Example #1
0
        /// <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);
            }
        }
Example #3
0
 // <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);
     }
 }
Example #4
0
 // <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);
     }
 }
Example #5
0
 /// <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);
            }
        }
Example #9
0
        // <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);
            }
        }
Example #10
0
        /// <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();
            }
        }
Example #11
0
        // <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);
            }
        }
Example #12
0
        /// <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);
            }
        }
Example #13
0
        /// <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());
            }
        }
Example #15
0
        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);
            }
        }
Example #16
0
        /// <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);
            }
        }
Example #17
0
        /// <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);
            }
        }
Example #18
0
        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);
            }
        }