public async Task <retEnvEvento> ManifestarAsync(ChaveFiscal chaveNFe, eTipoEventoNFe tipoEvento, string justificativa = null)
        {
            if (tipoEvento != eTipoEventoNFe.CienciaOperacao &&
                tipoEvento != eTipoEventoNFe.ConfirmacaoOperacao &&
                tipoEvento != eTipoEventoNFe.DesconhecimentoOperacao &&
                tipoEvento != eTipoEventoNFe.OperacaoNaoRealizada)
            {
                throw new Exception("Evento não permitido nesse serviço");
            }

            var xmlEvento = GerarXmlEvento(chaveNFe.Chave, tipoEvento, justificativa);

            var arqEnv = Path.Combine("Logs", Arquivo.MontarNomeArquivo("ped-eve.xml", config));
            await storage.SaveAsync(arqEnv, xmlEvento);

            await storage.SaveAsync($"{DateTime.Now.Ticks}-ped-eve.xml", xmlEvento);

            Schemas.ValidarSchema(eTipoServico.ManifestacaoDestinatario, xmlEvento, config);
            var envelope   = SoapEnvelopeFabrica.FabricarEnvelope(eTipoServico.ManifestacaoDestinatario, xmlEvento);
            var sefazUrl   = FabricarUrl.ObterUrl(eTipoServico.ManifestacaoDestinatario, config.TipoAmbiente, eModeloDocumento.NFe, eUF.AN);
            var xmlRetorno = await transmitir.TransmitirAsync(sefazUrl, envelope);

            var xmlRetLimpo = Soap.LimparEnvelope(xmlRetorno, "retEnvEvento").OuterXml;

            var arqRet = Path.Combine("Logs", Arquivo.MontarNomeArquivo("ret-eve.xml", config));
            await storage.SaveAsync(arqRet, xmlRetLimpo);

            var retEnvEvento = XmlUtils.XmlStringParaClasse <retEnvEvento>(xmlRetLimpo);

            return(retEnvEvento);
        }
        private async Task <string> PrepararTransmissao(distDFeInt distDFeInt, bool validarXmlConsulta = true)
        {
            var xml = XmlUtils.ClasseParaXmlString <distDFeInt>(distDFeInt);

            if (validarXmlConsulta)
            {
                Schemas.ValidarSchema(eTipoServico.NFeDistribuicaoDFe, xml, Configuracao);
            }

            var nomeArqEnv = $"{Configuracao.Emitente.CNPJ ?? Configuracao.Emitente.CPF}-{DateTime.Now.Ticks}-ped-DistDFeInt.xml";
            var arqEnv     = Path.Combine("Logs", nomeArqEnv);
            var stRet      = await storage.SaveAsync(arqEnv, xml);

            var envelope = SoapEnvelopeFabrica.FabricarEnvelope(eTipoServico.NFeDistribuicaoDFe, xml);

            var sefazUrl = FabricarUrl.ObterUrl(eTipoServico.NFeDistribuicaoDFe, Configuracao.TipoAmbiente, eModeloDocumento.NFe, eUF.AN);
            var retorno  = await Transmitir.TransmitirAsync(sefazUrl, envelope);

            var retornoLimpo = Soap.LimparEnvelope(retorno, "retDistDFeInt").OuterXml;

            var nomeArqRetorno = $"{Configuracao.Emitente.CNPJ ?? Configuracao.Emitente.CPF}-{DateTime.Now.Ticks}-retDistDFeInt.xml";
            var arqRet         = Path.Combine("Logs", nomeArqRetorno);
            await storage.SaveAsync(arqRet, retornoLimpo);

            return(retornoLimpo);
        }
        public async Task <retConsSitNFe> ConsultarPelaChave(string chaveAcesso)
        {
            chaveAcesso = chaveAcesso.Replace("NFe", "");
            var consSit = new consSitNFe
            {
                chNFe  = chaveAcesso,
                tpAmb  = cfgServico.TipoAmbiente,
                versao = versao
            };

            var xmlEvento = XmlUtils.ClasseParaXmlString <consSitNFe>(consSit);

            var arqEnv = Path.Combine("Logs", Arquivo.MontarNomeArquivo("pedConsSitNFe.xml", cfgServico));
            await storage.SaveAsync(arqEnv, xmlEvento);

            var modeloDoc = chaveAcesso.Substring(20, 2).ModeloDocumento();

            var sefazUrl = FabricarUrl.ObterUrl(eTipoServico.ConsultaSituacaoNFe, cfgServico.TipoAmbiente, modeloDoc, cfgServico.UF);
            var envelope = SoapEnvelopeFabrica.FabricarEnvelope(eTipoServico.ConsultaSituacaoNFe, xmlEvento);

            var retornoXmlString = await sefaz.TransmitirAsync(sefazUrl, envelope);

            var retornoXmlStringLimpa = Soap.LimparEnvelope(retornoXmlString, "retConsSitNFe").OuterXml;

            var arqRet = Path.Combine("Logs", Arquivo.MontarNomeArquivo("retConsSitNFe.xml", cfgServico));
            await storage.SaveAsync(arqRet, retornoXmlStringLimpa);

            var retEnvEvento = new retConsSitNFe().CarregarDeXmlString(retornoXmlStringLimpa, xmlEvento);

            return(retEnvEvento);
        }
        public virtual async Task <string> TransmitirAsync(UrlSefaz sefazUrl, XmlDocument envelope)
        {
            logger.LogInformation($"Iniciando transmissão Sefaz [{sefazUrl.Url}]");
            HttpWebRequest webRequest = SoapEnvelopeFabrica.CriarWebRequest(sefazUrl.Url, "application/soap+xml;charset=utf-8");

            Soap.InserirSoapEnvelopeWebRequest(envelope, webRequest);

            webRequest.ClientCertificates.Add(ObterCertificado.Obter(configuracao.ConfigCertificado));

            IAsyncResult asyncResult = webRequest.BeginGetResponse(null, null);

            string soapResult;

            using (WebResponse webResponse = webRequest.EndGetResponse(asyncResult))
            {
                using StreamReader rd = new StreamReader(webResponse.GetResponseStream());
                soapResult            = await rd.ReadToEndAsync();
            }

            logger.LogInformation($"Encerrando transmissão Sefaz");
            return(soapResult);
        }
        public async Task <retInutNFe> Inutilizar(int ano, eModeloDocumento modeloDocumento, int serie, int numeroInicial, int numeroFinal, string justificativa)
        {
            var cnpj            = cfgServico.Emitente.CNPJ ?? cfgServico.Emitente.CPF;
            var tpAmb           = cfgServico.TipoAmbiente;
            var uf              = cfgServico.UF;
            var pedInutilizacao = FabricarInutNFe(tpAmb, uf, ano, cnpj, modeloDocumento, serie, numeroInicial, numeroFinal, justificativa);

            var xmlInutilizacao = XmlUtils.ClasseParaXmlString <inutNFe>(pedInutilizacao);

            var arqEnv = Path.Combine("Logs", Arquivo.MontarNomeArquivo("ped-inut.xml", cfgServico));
            await storage.SaveAsync(arqEnv, xmlInutilizacao);

            var envelope         = SoapEnvelopeFabrica.FabricarEnvelope(eTipoServico.InutilizacaoNFe, xmlInutilizacao);
            var sefazUrl         = FabricarUrl.ObterUrl(eTipoServico.InutilizacaoNFe, cfgServico.TipoAmbiente, modeloDocumento, cfgServico.UF);
            var retornoXmlString = await transmitir.TransmitirAsync(sefazUrl, envelope);

            var retornoLimpo = Soap.LimparEnvelope(retornoXmlString, "retInutNFe").OuterXml;

            var arqRet = Path.Combine("Logs", Arquivo.MontarNomeArquivo("ret-inut.xml", cfgServico));
            await storage.SaveAsync(arqRet, retornoLimpo);

            return(XmlUtils.XmlStringParaClasse <retInutNFe>(retornoLimpo));
        }