public static int EnviarNotaFiscal(out NotaFiscal notaFiscal, out ConfiguracaoEntity config, Destinatario destinatario = null)
        {
            notaFiscal = null;
            config     = ConfiguracaoService.GetConfiguracao();
            var ambiente    = Ambiente.Homologacao;
            var modeloNota  = Modelo.Modelo65;
            var tipoEmissao = TipoEmissao.Normal;

            var documentoDanfe = destinatario != null ? destinatario.DocumentoDanfe : "CPF"; //Encapsular isso aqui

            var emitente = EmissorService.GetEmissor();
            var codigoUF = (CodigoUfIbge)Enum.Parse(typeof(CodigoUfIbge), emitente.Endereco.UF);
            var serie    = config.SerieNFCeHom;
            var numero   = config.ProximoNumNFCeHom;

            var identificacao = GetIdentificacao(codigoUF, DateTime.Now, emitente, modeloNota, Convert.ToInt32(serie), numero, tipoEmissao, ambiente, documentoDanfe);
            var produtos      = GetProdutos(config);
            var totalNFe      = GetTotalNFe();
            var pagamentos    = GetPagamentos();
            var infoAdicional = new InfoAdicional(produtos);
            var transporte    = new Transporte(modeloNota, null, null);

            notaFiscal = new NFe.Core.TO.NotaFiscal(emitente, destinatario, identificacao, transporte, totalNFe, infoAdicional, produtos, pagamentos);

            string            cscId       = config.CscIdHom;
            string            csc         = config.CscHom;
            NotaFiscalService notaService = new NotaFiscalService();

            return(notaService.EnviarNotaFiscalAsync(notaFiscal, cscId, csc).Result);
        }
示例#2
0
        public void NotaInutilizadaXmlExisteTest()
        {
            var config          = ConfiguracaoService.GetConfiguracao();
            var emitente        = EmissorService.GetEmissor();
            var codigoUFEnum    = (CodigoUfIbge)Enum.Parse(typeof(CodigoUfIbge), emitente.Endereco.UF);
            var numInutilizar   = config.ProximoNumNFCeHom;
            var serieInutilizar = Convert.ToInt32(config.SerieNFCeHom);

            var mensagemRetorno = new NotaInutilizadaService().InutilizarNotaFiscal(emitente.Endereco.UF, codigoUFEnum, Ambiente.Homologacao, emitente.CNPJ, Modelo.Modelo65, serieInutilizar.ToString(),
                                                                                    numInutilizar, numInutilizar);

            if (mensagemRetorno.Status == NFe.Core.Servicos.Status.SUCESSO)
            {
                config.ProximoNumNFCeHom = (Convert.ToInt32(config.ProximoNumNFCeHom) + 1).ToString();
                ConfiguracaoService.Salvar(config);
            }

            var notaInutilizadaTest = new NotaInutilizadaService().GetNotaInutilizada(mensagemRetorno.IdInutilizacao, true, false);

            ValidadorXml.ValidarXml(notaInutilizadaTest.LoadXml(), "procInutNFe_v4.00.xsd");

            Assert.IsTrue(File.Exists(notaInutilizadaTest.XmlPath));
        }
        private MensagemRetornoTransmissaoNotasContingencia TransmitirLoteNotasFiscaisContingencia(List <string> nfeList, Modelo modelo)
        {
            var lote = new TEnviNFe();

            lote.idLote  = "999999";              //qual a regra pra gerar o id?
            lote.indSinc = TEnviNFeIndSinc.Item0; //apenas uma nota no lote
            lote.versao  = "4.00";
            lote.NFe     = new TNFe[1];
            lote.NFe[0]  = new TNFe(); //Gera tag <NFe /> vazia para usar no replace

            string parametroXML = XmlUtil.Serialize(lote, "http://www.portalfiscal.inf.br/nfe");

            parametroXML = parametroXML.Replace("<NFe />", XmlUtil.GerarXmlListaNFe(nfeList)).Replace("<motDesICMS>1</motDesICMS>", string.Empty);

            var document = new XmlDocument();

            document.LoadXml(parametroXML);
            var node = document.DocumentElement;

            var config = ConfiguracaoService.GetConfiguracao();

            Ambiente         ambiente = config.IsProducao ? Ambiente.Producao : Ambiente.Homologacao;
            var              codigoUF = (CodigoUfIbge)Enum.Parse(typeof(CodigoUfIbge), EmissorService.GetEmissor().Endereco.UF);
            X509Certificate2 certificado;

            var certificadoEntity = new CertificadoRepository(new NFeContext()).GetCertificado();

            if (!string.IsNullOrWhiteSpace(certificadoEntity.Caminho))
            {
                certificado = CertificateManager.GetCertificateByPath(certificadoEntity.Caminho,
                                                                      RijndaelManagedEncryption.DecryptRijndael(certificadoEntity.Senha));
            }
            else
            {
                certificado = CertificateManager.GetCertificateBySerialNumber(certificadoEntity.NumeroSerial, false);
            }

            try
            {
                var servico = ServiceFactory.GetService(modelo, ambiente, Factory.Servico.AUTORIZACAO, codigoUF, certificado);
                var client  = (NFeAutorizacao4.NFeAutorizacao4SoapClient)servico.SoapClient;

                XmlNode     result  = client.nfeAutorizacaoLote(node);
                TRetEnviNFe retorno = (TRetEnviNFe)XmlUtil.Deserialize <TRetEnviNFe>(result.OuterXml);

                return(new MensagemRetornoTransmissaoNotasContingencia()
                {
                    RetEnviNFeInfRec = (TRetEnviNFeInfRec)retorno.Item,
                    TipoMensagem = TipoMensagem.Sucesso
                });
            }
            catch (Exception)
            {
                if (!_isFirstTimeResending)
                {
                    _isFirstTimeResending = true;
                    return(TransmitirLoteNotasFiscaisContingencia(nfeList, modelo));
                }
                else
                {
                    _isFirstTimeResending = false;

                    return(new MensagemRetornoTransmissaoNotasContingencia()
                    {
                        TipoMensagem = TipoMensagem.ServicoIndisponivel
                    });
                }
            }
        }
        private List <RetornoNotaFiscal> ConsultarReciboLoteContingencia(string nRec, Modelo modelo)
        {
            var config = ConfiguracaoService.GetConfiguracao();
            X509Certificate2 certificado = null;

            var certificadoEntity = CertificadoService.GetCertificado();

            if (!string.IsNullOrWhiteSpace(certificadoEntity.Caminho))
            {
                certificado = CertificateManager.GetCertificateByPath(certificadoEntity.Caminho,
                                                                      RijndaelManagedEncryption.DecryptRijndael(certificadoEntity.Senha));
            }
            else
            {
                certificado = CertificateManager.GetCertificateBySerialNumber(certificadoEntity.NumeroSerial, false);
            }

            var consultaRecibo = new TConsReciNFe();

            consultaRecibo.versao = "4.00";
            consultaRecibo.tpAmb  = config.IsProducao ? XmlSchemas.NfeRetAutorizacao.Envio.TAmb.Item1 : XmlSchemas.NfeRetAutorizacao.Envio.TAmb.Item2;
            consultaRecibo.nRec   = nRec;

            string parametroXML = XmlUtil.Serialize(consultaRecibo, "http://www.portalfiscal.inf.br/nfe");

            var node = new XmlDocument();

            node.LoadXml(parametroXML);

            Ambiente ambiente = config.IsProducao ? Ambiente.Producao : Ambiente.Homologacao;
            var      codigoUF = (CodigoUfIbge)Enum.Parse(typeof(CodigoUfIbge), EmissorService.GetEmissor().Endereco.UF);

            try
            {
                var servico = ServiceFactory.GetService(modelo, ambiente, Factory.Servico.RetAutorizacao, codigoUF, certificado);
                var client  = (NFeRetAutorizacao4.NFeRetAutorizacao4SoapClient)servico.SoapClient;

                var result = client.nfeRetAutorizacaoLote(node);

                TRetConsReciNFe          retorno             = (TRetConsReciNFe)XmlUtil.Deserialize <TRetConsReciNFe>(result.OuterXml);
                List <RetornoNotaFiscal> retornoConsultaList = new List <RetornoNotaFiscal>();

                foreach (var protNFe in retorno.protNFe)
                {
                    var retornoConsultaNota = new RetornoNotaFiscal();

                    retornoConsultaNota.Chave           = protNFe.infProt.chNFe;
                    retornoConsultaNota.CodigoStatus    = protNFe.infProt.cStat;
                    retornoConsultaNota.DataAutorizacao = protNFe.infProt.dhRecbto;
                    retornoConsultaNota.Motivo          = protNFe.infProt.xMotivo;
                    retornoConsultaNota.Protocolo       = protNFe.infProt.nProt;
                    retornoConsultaNota.Xml             = XmlUtil.Serialize(protNFe, string.Empty)
                                                          .Replace("<?xml version=\"1.0\" encoding=\"utf-8\"?>", string.Empty)
                                                          .Replace("TProtNFe", "protNFe")
                                                          .Replace("<infProt xmlns=\"http://www.portalfiscal.inf.br/nfe\">", "<infProt>");

                    retornoConsultaList.Add(retornoConsultaNota);
                }

                return(retornoConsultaList);
            }
            catch (Exception)
            {
                if (!_isFirstTimeRecheckingRecipts)
                {
                    _isFirstTimeRecheckingRecipts = true;
                    return(ConsultarReciboLoteContingencia(nRec, modelo));
                }
                else
                {
                    _isFirstTimeRecheckingRecipts = false;
                    return(null);
                }
            }
        }
        private async Task <List <string> > TransmitirConsultarLoteContingenciaAsync(ConfiguracaoEntity config, List <string> notasNFCe, Modelo modelo)
        {
            var retornoTransmissao = TransmitirLoteNotasFiscaisContingencia(notasNFCe, modelo);

            if (retornoTransmissao.TipoMensagem == TipoMensagem.ErroValidacao)
            {
                return(new List <string>()
                {
                    retornoTransmissao.Mensagem
                });
            }
            else if (retornoTransmissao.TipoMensagem == TipoMensagem.ServicoIndisponivel)
            {
                return(new List <string>()
                {
                    mensagemErro
                });
            }

            int           tempoEspera = Int32.Parse(retornoTransmissao.RetEnviNFeInfRec.tMed) * 1000;
            List <string> erros       = new List <string>();

            Thread.Sleep(tempoEspera);
            var resultadoConsulta = ConsultarReciboLoteContingencia(retornoTransmissao.RetEnviNFeInfRec.nRec, modelo);

            if (resultadoConsulta == null)
            {
                return(new List <string>()
                {
                    mensagemErro
                });
            }

            foreach (var resultado in resultadoConsulta)
            {
                var ambiente = config.IsProducao ? Ambiente.Producao : Ambiente.Homologacao;
                var nota     = new NotaFiscalService().GetNotaFiscalByChave(resultado.Chave);

                if (resultado.CodigoStatus == "100")
                {
                    nota.DataAutorizacao = DateTime.ParseExact(resultado.DataAutorizacao, "yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture);
                    nota.Protocolo       = resultado.Protocolo;
                    nota.Status          = (int)NFe.Repository.Status.ENVIADA;

                    string xml = await nota.LoadXmlAsync();

                    xml = xml.Replace("<protNFe />", resultado.Xml);

                    var notaFiscalService = new NotaFiscalService();

                    await notaFiscalService.SalvarAsync(nota, xml);
                }
                else
                {
                    if (resultado.Motivo.Contains("Duplicidade"))
                    {
                        X509Certificate2 certificado;
                        var certificadoEntity = new CertificadoRepository(new NFeContext()).GetCertificado();
                        var emitente          = EmissorService.GetEmissor();

                        if (!string.IsNullOrWhiteSpace(certificadoEntity.Caminho))
                        {
                            certificado = CertificateManager.GetCertificateByPath(certificadoEntity.Caminho,
                                                                                  RijndaelManagedEncryption.DecryptRijndael(certificadoEntity.Senha));
                        }
                        else
                        {
                            certificado = CertificateManager.GetCertificateBySerialNumber(certificadoEntity.NumeroSerial, false);
                        }

                        var retornoConsulta = NFeConsulta.ConsultarNotaFiscal
                                              (
                            nota.Chave,
                            emitente.Endereco.CodigoUF,
                            certificado,
                            config.IsProducao ? Ambiente.Producao : Ambiente.Homologacao,
                            nota.Modelo.Equals("65") ? Modelo.Modelo65 : Modelo.Modelo55
                                              );

                        if (retornoConsulta.IsEnviada)
                        {
                            var protSerialized = XmlUtil.Serialize(retornoConsulta.Protocolo, string.Empty)
                                                 .Replace("<?xml version=\"1.0\" encoding=\"utf-8\"?>", string.Empty)
                                                 .Replace("TProtNFe", "protNFe");

                            protSerialized = Regex.Replace(protSerialized, "<infProt (.*?)>", "<infProt>");

                            nota.DataAutorizacao = retornoConsulta.DhAutorizacao;
                            nota.Protocolo       = retornoConsulta.Protocolo.infProt.nProt;
                            nota.Status          = (int)NFe.Repository.Status.ENVIADA;

                            string xml = await nota.LoadXmlAsync();

                            xml = xml.Replace("<protNFe />", protSerialized);

                            var notaFiscalService = new NotaFiscalService();

                            await notaFiscalService.SalvarAsync(nota, xml);
                        }
                        else
                        {
                            erros.Add(string.Format("Modelo: {0} Nota: {1} Série: {2} \nMotivo: {3}", nota.Modelo, nota.Numero, nota.Serie, resultado.Motivo)); //O que fazer com essas mensagens de erro?
                        }
                    }
                    else
                    {
                        erros.Add(string.Format("Modelo: {0} Nota: {1} Série: {2} \nMotivo: {3}", nota.Modelo, nota.Numero, nota.Serie, resultado.Motivo)); //O que fazer com essas mensagens de erro?
                    }
                }
            }

            return(erros);
        }