Пример #1
0
        public void EnviarEmailCartaCorrecao(string destinatario, CartaCorrecao.TProcEvento evento)
        {
            if (String.IsNullOrWhiteSpace(Configuracao.MensagemEmail))
            {
                throw new Exception("Erro ao enviar o email. Motivo: Corpo de email não configurado");
            }

            foreach (var nota in NotasFiscais)
            {
                EnviaMensagemEmailCartaCorrecao(nota, evento, destinatario, "", "", Configuracao.AssuntoEmail, String.Format(Configuracao.MensagemEmail, nota.NFe.infNFe.ide.nNF));
            }
        }
 /// <summary>
 /// Deserializes workflow markup into an TProcEvento object
 /// </summary>
 /// <param name="xml">string workflow markup to deserialize</param>
 /// <param name="obj">Output TProcEvento object</param>
 /// <param name="exception">output Exception value if deserialize failed</param>
 /// <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
 public static bool Deserialize(string xml, out TProcEvento obj, out System.Exception exception)
 {
     exception = null;
     obj       = default(TProcEvento);
     try
     {
         obj = Deserialize(xml);
         return(true);
     }
     catch (System.Exception ex)
     {
         exception = ex;
         return(false);
     }
 }
Пример #3
0
 public void SalvarEventoCorrecao(ref CartaCorrecao.TProcEvento procEvento, string dataEmissao)
 {
     procEvento.NomeArquivo = GetFileNameEventoCorrecao(procEvento.evento.infEvento, dataEmissao);
     procEvento.ArquivoXML  = SaveXml(procEvento.Serialize(), procEvento.NomeArquivo);
 }
Пример #4
0
        private void EnviaMensagemEmailCartaCorrecao(TNfeProc nota, CartaCorrecao.TProcEvento evento, string destinatario, string bcc, string cc, string assunto, string corpo)
        {
            if (string.IsNullOrEmpty(Configuracao.ConfiguracaoMail.SMTPServer))
            {
                throw new Exception("É necessário preencher a propriedade ConfiguracaoEmail para enviar email");
                //return;
            }

            var mMailMessage = new MailMessage {
                From = new MailAddress(Configuracao.ConfiguracaoMail.Remetente)
            };

            var arrDestinatarios = destinatario.Split(';');

            foreach (var email in arrDestinatarios.Where(email => !String.IsNullOrEmpty(email)))
            {
                mMailMessage.To.Add(new MailAddress(email.Trim()));
            }

            if ((bcc != null) & bcc != string.Empty)
            {
                mMailMessage.Bcc.Add(new MailAddress(bcc));
            }

            if ((cc != null) & cc != string.Empty)
            {
                mMailMessage.CC.Add(new MailAddress(cc));
            }

            mMailMessage.Subject    = assunto;
            mMailMessage.Body       = corpo;
            mMailMessage.IsBodyHtml = Configuracao.ConfiguracaoMail.CorpoHtml;
            mMailMessage.Priority   = MailPriority.Normal;

            var servidorSMTP = Configuracao.ConfiguracaoMail.SMTPServer;
            var mSmtpClient  = new SmtpClient(servidorSMTP)
            {
                Port      = Configuracao.ConfiguracaoMail.Port,
                EnableSsl = Configuracao.ConfiguracaoMail.HabilitaSSL
            };

            //Configurar a conta de envio
            var usuario = Configuracao.ConfiguracaoMail.Usuario;
            var senha   = Configuracao.ConfiguracaoMail.Senha;

            mSmtpClient.Credentials = new System.Net.NetworkCredential(usuario, senha);
            //mSmtpClient.UseDefaultCredentials = True
            mMailMessage.DeliveryNotificationOptions = DeliveryNotificationOptions.OnSuccess;

            //Anexa o XML
            var anexo = new Attachment(evento.NomeArquivo);

            mMailMessage.Attachments.Add(anexo);

            //Anexa o PDF
            var arquivoPDF = NfeConvert.ToPDFCartaCorrecao(nota, evento, Configuracao);
            var anexoPDF   = new Attachment(arquivoPDF);

            mMailMessage.Attachments.Add(anexoPDF);

            //Enviar email
            try
            {
                mSmtpClient.Send(mMailMessage);
            }
            catch (Exception ex)
            {
                throw new Exception("Erro ao enviar o email do evento: " + evento.retEvento.infEvento.chNFe + " para: " + destinatario + ". Motivo: " + ex.Message);
            }

            //File.Delete(arquivoPDF);
        }
Пример #5
0
        public CartaCorrecao.TRetEnvEvento CartaCorrecao(string correcao, int numLote, int nSequencia, out CartaCorrecao.TProcEvento procCorrecao)
        {
            if (NotasFiscais.Count > 1)
            {
                throw new InvalidOperationException("Só é possível corrigir uma nota por vez.");
            }
            var nota = NotasFiscais[0];

            correcao = Funcoes.RemoverAcentos(correcao.Trim());
            var ws          = new C_WebService(Configuracao.PastaLog);
            var retCorrecao = ws.CartaCorrecao(nota, correcao, Certificado, numLote, nSequencia, Configuracao.Ambiente, out procCorrecao);

            if (retCorrecao.retEvento[0].infEvento.cStat == "135")
            {
                SalvarEventoCorrecao(ref procCorrecao, nota.NFe.infNFe.ide.dEmi);
            }
            return(retCorrecao);
        }
Пример #6
0
        public CartaCorrecao.TRetEnvEvento CartaCorrecao(TNfeProc nota, string Correcao, X509Certificate2 pCertificado, int numLote, int nSequencia, TAmb ambiente, out ACBr.Net.NFe.CartaCorrecao.TProcEvento procEvento)
        {
            string arqPedCorecao = _PastaLog + nota.NFe.infNFe.Id.Substring(3) + "-ped-evento.xml";//-ped-cce.xml ???
            string retPedCorrecao = _PastaLog + nota.NFe.infNFe.Id.Substring(3) + "-eve.xml";
            C_WebService.ListaUrl listaURL = default(C_WebService.ListaUrl);
            listaURL = WsUrls.BuscaURL(nota.NFe.infNFe.ide.cUF, ambiente);

            #region evento
            CartaCorrecao.TEvento evento = new CartaCorrecao.TEvento();
            evento.versao = "1.00";

            #region infEvento
            CartaCorrecao.TEventoInfEvento infEvento = new CartaCorrecao.TEventoInfEvento();
            infEvento.tpAmb = ambiente;
            infEvento.chNFe = nota.NFe.infNFe.Id.Substring(3);
            infEvento.cOrgao = PegarCodigoOrgaoUF(nota.NFe.infNFe.ide.cUF);
            infEvento.dhEvento = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzzz");
            infEvento.Id = "ID" + "110110" + nota.NFe.infNFe.Id.Substring(3) + nSequencia.ToString("D2");
            infEvento.ItemElementName = ACBr.Net.NFe.CartaCorrecao.ItemChoiceTypeCC.CNPJ;
            infEvento.Item = nota.NFe.infNFe.emit.Item;
            infEvento.nSeqEvento = nSequencia.ToString();
            infEvento.verEvento = ACBr.Net.NFe.CartaCorrecao.TEventoInfEventoVerEvento.Item100;
            infEvento.tpEvento = ACBr.Net.NFe.CartaCorrecao.TEventoInfEventoTpEvento.Item110110;

            #region detEvento
            CartaCorrecao.TEventoInfEventoDetEvento detEvento = new CartaCorrecao.TEventoInfEventoDetEvento();
            detEvento.descEvento = ACBr.Net.NFe.CartaCorrecao.TEventoInfEventoDetEventoDescEvento.CartadeCorrecao;
            detEvento.versao = ACBr.Net.NFe.CartaCorrecao.TEventoInfEventoDetEventoVersao.Item100;
            detEvento.xCondUso = ACBr.Net.NFe.CartaCorrecao.TEventoInfEventoDetEventoXCondUso.ACartadeCorrecaoedisciplinadapeloparagrafo1oAdoart7odoConvenioSNde15dedezembrode1970epodeserutilizadapararegularizacaodeerroocorridonaemissaodedocumentofiscaldesdequeoerronaoestejarelacionadocomIasvariaveisquedeterminamovalordoimpostotaiscomobasedecalculoaliquotadiferencadeprecoquantidadevalordaoperacaooudaprestacaoIIacorrecaodedadoscadastraisqueimpliquemudancadoremetenteoudodestinatarioIIIadatadeemissaooudesaida;
            detEvento.xCorrecao = Correcao;
            #endregion detEvento

            infEvento.detEvento = detEvento;
            #endregion infEvento

            evento.infEvento = infEvento;

            XmlDocument xmldoc = new XmlDocument();
            xmldoc.LoadXml(Funcoes.RemoveNameSpaceFromXml(evento.Serialize()));
            xmldoc = CertificadoDigital.Assinar(xmldoc, "infEvento", pCertificado);
            xmldoc.Save(arqPedCorecao);

            #endregion evento

            dynamic envEvento = GeraLoteEvento(arqPedCorecao, numLote);

            try
            {
                RecepcaoEvento.nfeCabecMsg cab = new RecepcaoEvento.nfeCabecMsg();
                RecepcaoEvento.RecepcaoEvento wsMsg = default(RecepcaoEvento.RecepcaoEvento);

                // UF E VERSÃO DO CABEÇALHO
                cab.cUF = PegarCodigoUF(nota.NFe.infNFe.ide.cUF);
                cab.versaoDados = "1.00";

                //CABEÇALHO USADA PARA ENVIO DE LOTE
                wsMsg = new RecepcaoEvento.RecepcaoEvento(listaURL.UrlRecepcaoEvento);
                wsMsg.nfeCabecMsgValue = cab;
                wsMsg.Timeout = 100000;
                wsMsg.ClientCertificates.Add(pCertificado);
                wsMsg.SoapVersion = SoapProtocolVersion.Soap12;

                //RETORNO DA SEFAZ
                XmlElement strRetorno = wsMsg.nfeRecepcaoEvento(envEvento);
                XmlDocument xmlRetorno = new XmlDocument();
                xmlRetorno.LoadXml(strRetorno.OuterXml);
                xmlRetorno.Save(retPedCorrecao);

                ACBr.Net.NFe.CartaCorrecao.TRetEnvEvento retCorrecaoNFe = ACBr.Net.NFe.CartaCorrecao.TRetEnvEvento.LoadFromFile(retPedCorrecao);

                //saída
                procEvento = new CartaCorrecao.TProcEvento();
                procEvento.evento = ACBr.Net.NFe.CartaCorrecao.TEvento.Deserialize(xmldoc.OuterXml);
                procEvento.retEvento = retCorrecaoNFe.retEvento[0];
                procEvento.versao = "1.00";

                return retCorrecaoNFe;
            }
            catch (Exception ex)
            {
                throw new System.InvalidOperationException("Erro ao corrigir NFe. Erro: " + ex.Message);
            }
        }
 public static bool LoadFromFile(string fileName, out TProcEvento obj)
 {
     System.Exception exception = null;
     return(LoadFromFile(fileName, out obj, out exception));
 }
 public static bool LoadFromFile(string fileName, out TProcEvento obj, out System.Exception exception)
 {
     return(LoadFromFile(fileName, Encoding.UTF8, out obj, out exception));
 }
 /// <summary>
 /// Deserializes xml markup from file into an TProcEvento object
 /// </summary>
 /// <param name="fileName">string xml file to load and deserialize</param>
 /// <param name="obj">Output TProcEvento object</param>
 /// <param name="exception">output Exception value if deserialize failed</param>
 /// <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
 public static bool LoadFromFile(string fileName, System.Text.Encoding encoding, out TProcEvento obj, out System.Exception exception)
 {
     exception = null;
     obj       = default(TProcEvento);
     try
     {
         obj = LoadFromFile(fileName, encoding);
         return(true);
     }
     catch (System.Exception ex)
     {
         exception = ex;
         return(false);
     }
 }
 public static bool Deserialize(string xml, out TProcEvento obj)
 {
     System.Exception exception = null;
     return(Deserialize(xml, out obj, out exception));
 }
 public static bool LoadFromFile(string fileName, out TProcEvento obj)
 {
     System.Exception exception = null;
     return LoadFromFile(fileName, out obj, out exception);
 }
 public static bool LoadFromFile(string fileName, out TProcEvento obj, out System.Exception exception)
 {
     return LoadFromFile(fileName, Encoding.UTF8, out obj, out exception);
 }
 /// <summary>
 /// Deserializes xml markup from file into an TProcEvento object
 /// </summary>
 /// <param name="fileName">string xml file to load and deserialize</param>
 /// <param name="obj">Output TProcEvento object</param>
 /// <param name="exception">output Exception value if deserialize failed</param>
 /// <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
 public static bool LoadFromFile(string fileName, System.Text.Encoding encoding, out TProcEvento obj, out System.Exception exception)
 {
     exception = null;
     obj = default(TProcEvento);
     try
     {
         obj = LoadFromFile(fileName, encoding);
         return true;
     }
     catch (System.Exception ex)
     {
         exception = ex;
         return false;
     }
 }
 public static bool Deserialize(string xml, out TProcEvento obj)
 {
     System.Exception exception = null;
     return Deserialize(xml, out obj, out exception);
 }
 /// <summary>
 /// Deserializes workflow markup into an TProcEvento object
 /// </summary>
 /// <param name="xml">string workflow markup to deserialize</param>
 /// <param name="obj">Output TProcEvento object</param>
 /// <param name="exception">output Exception value if deserialize failed</param>
 /// <returns>true if this XmlSerializer can deserialize the object; otherwise, false</returns>
 public static bool Deserialize(string xml, out TProcEvento obj, out System.Exception exception)
 {
     exception = null;
     obj = default(TProcEvento);
     try
     {
         obj = Deserialize(xml);
         return true;
     }
     catch (System.Exception ex)
     {
         exception = ex;
         return false;
     }
 }