Esempio n. 1
0
        /// <summary>
        /// VerConsultaCadastroClass
        /// </summary>
        /// <param name="XmlNfeDadosMsg"></param>
        /// <returns></returns>
        public object VerConsultaCadastro(string XmlNfeDadosMsg)
        {
            Auxiliar oAux   = new Auxiliar();
            GerarXML oGerar = new GerarXML(Emp);

            string ArqXMLRetorno = Empresa.Configuracoes[Emp].PastaRetorno + "\\" +
                                   oAux.ExtrairNomeArq(XmlNfeDadosMsg, ExtXml.ConsCad) +
                                   "-ret-cons-cad.xml";

            string ArqERRRetorno = Empresa.Configuracoes[Emp].PastaRetorno + "\\" +
                                   oAux.ExtrairNomeArq(XmlNfeDadosMsg, ExtXml.ConsCad) +
                                   "-ret-cons-cad.err";

            object vRetorno = null;

            try
            {
                vRetorno = EnviaArquivoERecebeResposta(2, ArqXMLRetorno, ArqERRRetorno);
                //vRetorno = ProcessaConsultaCadastroClass(@"c:\usr\nfe\uninfe\modelos\retorno-cons-cad.txt");
            }
            finally
            {
                oAux.DeletarArquivo(ArqERRRetorno);
                oAux.DeletarArquivo(ArqXMLRetorno);
            }
            return(vRetorno);
        }
Esempio n. 2
0
        private void buttonStatusServidor_Click(object sender, EventArgs e)
        {
            this.toolStripStatusLabel1.Text = _wait;
            this.textResultado.Text         = "";
            this.Refresh();

            this.Cursor = Cursors.WaitCursor;
            try
            {
                GerarXML oGerar = new GerarXML(Emp);
                Auxiliar oAux   = new Auxiliar();

                int cUF = ((ComboElem)(new System.Collections.ArrayList(arrUF))[comboUf.SelectedIndex]).Codigo;
                int amb = ((ComboElem)(new System.Collections.ArrayList(arrAmb))[cbAmbiente.SelectedIndex]).Codigo;

                string XmlNfeDadosMsg = Empresa.Configuracoes[Emp].PastaEnvio + "\\" + oGerar.StatusServico(this.cbEmissao.SelectedIndex + 1, cUF, amb);

                //Demonstrar o status do serviço
                this.textResultado.Text = VerStatusServico(XmlNfeDadosMsg);
            }
            catch (Exception ex)
            {
                this.textResultado.Text = ex.Message;
            }
            finally
            {
                this.Cursor = Cursors.Default;
                this.toolStripStatusLabel1.Text = "";
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Verifica um cadastro no site da receita.
        /// Voce deve preencher o estado e mais um dos tres itens: CPNJ, IE ou CPF.
        /// </summary>
        /// <param name="uf">Sigla do UF do cadastro a ser consultado. Tem que ter dois dígitos. SU para suframa.</param>
        /// <param name="cnpj"></param>
        /// <param name="ie"></param>
        /// <param name="cpf"></param>
        /// <returns>String com o resultado da consuta do cadastro</returns>
        /// <by>Marcos Diez</by>
        /// <date>29/08/2009</date>
        public object ConsultaCadastro(string uf, string cnpj, string ie, string cpf)
        {
            GerarXML oGerar = new GerarXML(Emp);

            //Criar XML para obter o cadastro do contribuinte
            string XmlNfeConsultaCadastro = oGerar.ConsultaCadastro(string.Empty, uf, cnpj, ie, cpf, this.cbVersao.SelectedItem.ToString());

            return(VerConsultaCadastro(XmlNfeConsultaCadastro));
        }
Esempio n. 4
0
        private async System.Threading.Tasks.Task ValidarXMLAsync(int id)
        {
            var arquivo = new GerarXML();

            arquivo.DUEId = id;
            arquivo.Validar(ModelState);
            if (!ModelState.IsValid)
            {
                return;
            }
            arquivo.Gerar();
            var validarXML = new ValidarXML();

            var         xml          = dueDAO.ObterUltimoXMLGerado(arquivo.DUEId);
            XmlDocument documentoXML = new XmlDocument();

            documentoXML.LoadXml(xml);

            var retorno = await validarXML.Validar(documentoXML);

            ViewState["RetornoSucesso"] = retorno.Sucesso;

            dueDAO.AtualizarXMLRetorno(id, retorno.XmlRetorno);

            alertaValidacao.Visible = retorno.Sucesso;

            if (retorno.Mensagens.Count > 0 & retorno.XmlRetorno != null)
            {
                alertaValidacao.Visible     = true;
                ViewState["RetornoSucesso"] = null;
            }

            if (!retorno.Sucesso & retorno.XmlRetorno == null)
            {
                foreach (var erro in retorno.Mensagens)
                {
                    ModelState.AddModelError(string.Empty, erro);
                }
            }
            else if (!retorno.Sucesso & retorno.XmlRetorno != null)
            {
                //Response.Redirect("ArquivoXML.aspx?id=" + id + "&dest=SALVAR&tipo=RETORNO", false);
                StringBuilder conteudo = new StringBuilder();
                foreach (var erro in retorno.Mensagens)
                {
                    conteudo.AppendLine(erro);
                }

                SalvarTXT(arquivo.DUE.DUE, conteudo);
            }
        }
Esempio n. 5
0
        protected async void gvDUE_RowCommand(object sender, System.Web.UI.WebControls.GridViewCommandEventArgs e)
        {
            if (this.gvDUE.Rows.Count == 0)
            {
                return;
            }

            if (e.CommandName == "EXCLUIR")
            {
                var index = Convert.ToInt32(e.CommandArgument);

                var dueId = this.gvDUE.DataKeys[index]["Id"].ToString().ToInt();

                var due = dueDAO.ObterDUEPorId(dueId);

                if (due != null)
                {
                    dueDAO.ExcluirDUE(dueId);
                    ConsultarDUEs();
                }
            }

            if (e.CommandName == "GerarXML")
            {
                var index   = Convert.ToInt32(e.CommandArgument);
                var arquivo = new GerarXML();
                arquivo.DUEId = this.gvDUE.DataKeys[index]["Id"].ToString().ToInt();
                arquivo.Validar(ModelState);
                if (!ModelState.IsValid)
                {
                    return;
                }
                arquivo.Gerar();
            }

            if (e.CommandName == "ValidarXML")
            {
                var index = Convert.ToInt32(e.CommandArgument);

                await ValidarXMLAsync(this.gvDUE.DataKeys[index]["Id"].ToString().ToInt());
            }

            if (e.CommandName == "EnviarSiscomex")
            {
                var index   = Convert.ToInt32(e.CommandArgument);
                var arquivo = new GerarXML();
                arquivo.DUEId = this.gvDUE.DataKeys[index]["Id"].ToString().ToInt();

                arquivo.Retificar(ModelState);
            }
        }
        private void GerarConsulta(int emp, TipoAplicativo servico, int tpEmis, int cUF, int amb, string versao, List <ConsultaRealizada> consultasRealizadas)
        {
            GerarXML oGerar = new GerarXML(emp);

            string XmlNfeDadosMsg = Empresas.Configuracoes[emp].PastaXmlEnvio + "\\" + oGerar.StatusServico(servico, tpEmis, cUF, amb, versao);

            consultasRealizadas.Add(new ConsultaRealizada
            {
                ArquivoRetorno = XmlNfeDadosMsg,
                Empresa        = Empresas.Configuracoes[emp],
                Emp            = emp,
                Servico        = servico
            });

            Thread.Sleep(1000);
        }
Esempio n. 7
0
 /// <summary>
 /// Gerar o XML de consulta do recibo do lote da nfe
 /// </summary>
 /// <param name="empresa">Código da empresa</param>
 /// <param name=TpcnResources.nRec.ToString()>Número do recibo a ser consultado</param>
 /// <param name="versao">Versao do Schema XML</param>
 /// <param name="mod">Modelo do documento fiscal</param>
 public void XmlPedRec(int empresa, string nRec, string versao, string mod)
 {
     GerarXML gerarXML = new GerarXML(empresa);
     gerarXML.XmlPedRec(mod, nRec, versao);
 }
Esempio n. 8
0
 /// <summary>
 /// Auxiliar na geração do arquivo XML de consulta do recibo do lote quando estivermos utilizando o InvokeMember para chamar este método
 /// </summary>
 /// <param name="pFinalArqEnvio">Final do nome do arquivo de solicitação do serviço.</param>
 /// <param name="pFinalArqRetorno">Final do nome do arquivo que é para ser gravado o retorno.</param>
 /// <date>07/08/2009</date>
 /// <by>Wandrey Mundin Ferreira</by>
 public override void XmlPedRec(int empresa, string nRec)
 {
     GerarXML gerarXML = new GerarXML(empresa);
     gerarXML.XmlPedRec(nRec);
 }
        static void Main(string[] args)
        {
            //NumDoc 154988

            (new EmitenteDao()).SelecionaEmitente();

            Certificado.getInstance.Seleciona_Certificado();

            GerarXML.str_Ambiente = "2";



            Controle control = (new ControleNFiscalDao()).getControle();

            if (control != null)
            {
                Controle.getInstance.ultima_NFCe            = control.ultima_NFCe;
                Controle.getInstance.csc_Homologacao        = control.csc_Homologacao;
                Controle.getInstance.csc_Producao           = control.csc_Producao;
                Controle.getInstance.caminho_XMLAutorizado  = control.caminho_XMLAutorizado;
                Controle.getInstance.caminho_XMLCancelado   = control.caminho_XMLCancelado;
                Controle.getInstance.caminho_XMLInutilizado = control.caminho_XMLInutilizado;

                control = null;
            }



            Pedido pedido = (new PedidoDao()).getPedido(247259);

            //pedido.cliente = (new ClienteDao()).getClientePedido(pedido.numdoc);
            pedido.cliente     = (new ClienteDao()).getClientePedido(247259);
            pedido.cliente.end = ((new EnderecoDao()).getEnderecoCliente(pedido.numdoc));

            pedido.operacao      = (new OperacaoDao()).getOperacaoPedido(pedido.numdoc);
            pedido.lstPedidoItem = (new PedidoItemDao()).getlst_Itens(pedido.numdoc);

            //pedido.emitente = (new EmitenteDao()).getEmitente();
            //pedido.emitente.endereco = (new EnderecoDao()).getEnderecoEmitente();

            ProdutoDao pd = new ProdutoDao();

            foreach (PedidoItem pedidoitem in pedido.lstPedidoItem)
            {
                pedidoitem.produto              = pd.getProduto(pedidoitem.codpro);
                pedidoitem.produto.subGrupo     = pd.getSubGrupo(pedidoitem.produto.codgrupo, pedidoitem.produto.codsubGrupo);
                pedidoitem.produto.produto_loja = new Produto_Loja {
                    desconto = 0
                };
            }

            pedido.nfiscal = "81";


            GerarXML geraxml = new GerarXML();
            var      xml     = geraxml.NFe(pedido);


            var xmlAssinado = (new AssinarXML()).AssinaXML(xml.InnerXml, "infNFe", Certificado.getInstance.oCertificado);


            //========================================================================
            var Grava = File.CreateText(@"C:\Users\Admin\Desktop\XML_GERADO.XML");

            Grava.Write(xmlAssinado.InnerXml);
            Grava.Close();
            //========================================================================



            var retValidar = (new ValidarXML()).Valida(xmlAssinado, "NFe");

            //========================================================================
            Grava = File.CreateText(@"C:\Users\Admin\Desktop\XML_VALIDADO.XML");
            Grava.Write(retValidar);
            Grava.Close();
            //========================================================================


            var urlQRCode = geraxml.Gera_Url_QRCode(xmlAssinado, pedido);

            //Inserindo a URL QRCode no xml já assinado
            xmlAssinado.LoadXml(xmlAssinado.InnerXml.Replace("</infNFe>", "</infNFe><infNFeSupl><qrCode><![CDATA[" + urlQRCode + "]]></qrCode><urlChave>http://www4.fazenda.rj.gov.br/consultaNFCe/QRCode</urlChave></infNFeSupl>"));


            //========================================================================
            Grava = File.CreateText(@"C:\Users\Admin\Desktop\XML_ASSINADO_QRCODE.XML");
            Grava.Write(xmlAssinado.InnerXml);
            Grava.Close();
            //========================================================================


            string retTransmitir = "";

            if (retValidar == string.Empty)
            {
                retTransmitir = (new TransmitirXML()).XML_NFCe4(xmlAssinado, pedido.nfiscal, Certificado.getInstance.oCertificado);
            }
            else
            {
                Console.Write(retValidar);
            }


            //========================================================================
            Grava = File.CreateText(@"C:\Users\Admin\Desktop\XML_EMITIDO.XML");
            Grava.Write(retTransmitir);
            Grava.Close();
            //========================================================================



            //MP2032.ConfiguraModeloImpressora(7); // Bematech MP-4200 TH
            //MP2032.IniciaPorta("USB");

            //pedido.chave = "33180911500080000160650010000001011757287148";

            //ProjetoPDVUtil.ImpressoraBema.GeraDANFE_NFCe(pedido, urlQRCode);


            //MP2032.FechaPorta();


            //printa(servico.GeraLote(x));



            Console.Write("Fim");
            //Console.ReadKey();
        }
        private const int _Minutos = 10;  //10 minutos?

        public NFeEmProcessamento()
        {
            int emp = new FindEmpresaThread(Thread.CurrentThread).Index;

            if (Empresa.Configuracoes[emp].UltimaVerificacaoEmProcessamento.Year > 1)
            {
                ///
                /// executa de 10x10 minutos para evitar ter que acessar o HD sem necessidade
                ///
                DateTime dCheck = Empresa.Configuracoes[emp].UltimaVerificacaoEmProcessamento.AddMinutes(_Minutos);
                if (dCheck > DateTime.Now)
                {
                    return;
                }
            }

            Empresa.Configuracoes[emp].UltimaVerificacaoEmProcessamento = DateTime.Now;
            this.oAux = new Auxiliar();

            try
            {
                ///
                /// le todos os arquivos que estão na pasta em processamento
                ///
                string[] files = Directory.GetFiles(Empresa.Configuracoes[emp].PastaEnviado + "\\" + PastaEnviados.EmProcessamento.ToString(),
                                                    "*" + ExtXml.Nfe,
                                                    SearchOption.TopDirectoryOnly);
                ///
                /// considera os arquivos em que a data do ultimo acesso é superior a 10 minutos
                ///
                DateTime UltimaData = DateTime.Now.AddMinutes(-_Minutos);

                foreach (string file in files)
                {
                    if (!Auxiliar.FileInUse(file))
                    {
                        FileInfo fi = new FileInfo(file);

                        //usar a última data de acesso, e não a data de criação
                        if (fi.LastWriteTime <= UltimaData)
                        {
                            if (this.oLerXml == null)
                            {
                                this.oLerXml   = new LerXML();
                                this.oGerarXml = new GerarXML(emp);
                                this.fluxo     = new FluxoNfe();
                            }

                            try
                            {
                                //Ler a NFe
                                oLerXml.Nfe(file);

                                //Verificar se o -nfe.xml existe na pasta de autorizados
                                bool NFeJaNaAutorizada = oAux.EstaAutorizada(file, oLerXml.oDadosNfe.dEmi, ExtXml.Nfe);

                                //Verificar se o -procNfe.xml existe na past de autorizados
                                bool procNFeJaNaAutorizada = oAux.EstaAutorizada(file, oLerXml.oDadosNfe.dEmi, ExtXmlRet.ProcNFe);

                                //Se um dos XML´s não estiver na pasta de autorizadas ele força finalizar o processo da NFe.
                                if (!NFeJaNaAutorizada || !procNFeJaNaAutorizada)
                                {
                                    //Verificar se a NFe está no fluxo, se não estiver vamos incluir ela para que funcione
                                    //a rotina de gerar o -procNFe.xml corretamente. Wandrey 21/10/2009
                                    if (!fluxo.NfeExiste(oLerXml.oDadosNfe.chavenfe))
                                    {
                                        fluxo.InserirNfeFluxo(oLerXml.oDadosNfe.chavenfe, oAux.ExtrairNomeArq(file, ExtXml.Nfe) + ExtXml.Nfe);
                                    }

                                    //gera um -ped-sit.xml mesmo sendo autorizada ou denegada, pois assim sendo, o ERP precisaria dele
                                    string vArquivoSit = oLerXml.oDadosNfe.chavenfe.Substring(3);

                                    oGerarXml.Consulta(vArquivoSit + ExtXml.PedSit,
                                                       Convert.ToInt32(oLerXml.oDadosNfe.tpAmb),
                                                       Convert.ToInt32(oLerXml.oDadosNfe.tpEmis),
                                                       oLerXml.oDadosNfe.chavenfe.Substring(3));
                                }
                                else
                                {
                                    //Move o XML da pasta em processamento para a pasta de XML´s com erro (-nfe.xml)
                                    oAux.MoveArqErro(file);

                                    //Move o XML da pasta em processamento para a pasta de XML´s com erro (-procNFe.xml)
                                    oAux.MoveArqErro(Empresa.Configuracoes[emp].PastaEnviado + "\\" + PastaEnviados.EmProcessamento.ToString() + "\\" + oAux.ExtrairNomeArq(file, ExtXml.Nfe) + ExtXmlRet.ProcNFe);

                                    //Tirar a nota fiscal do fluxo
                                    fluxo.ExcluirNfeFluxo(oLerXml.oDadosNfe.chavenfe);
                                }
                            }
                            catch (Exception ex)
                            {
                                ///
                                /// grava o arquivo com extensao .ERR
                                ///
                                oAux.GravarArqErroERP(Path.GetFileNameWithoutExtension(file) + ".err", ex.Message);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                ///
                /// grava o arquivo generico
                ///
                oAux.GravarArqErroERP(string.Format(InfoApp.NomeArqERRUniNFe, DateTime.Now.ToString("yyyyMMddThhmmss")), ex.Message);
            }
        }
Esempio n. 11
0
        private void buttonPesquisa_Click(object sender, EventArgs e)
        {
            this.textResultado.Clear();
            this.Refresh();

            try
            {
                TipoAplicativo servico = (TipoAplicativo)cbServico.SelectedValue;
                TipoEmissao tpEmis = (TipoEmissao)this.cbEmissao.SelectedValue;

                switch (servico)
                {
                    case TipoAplicativo.Cte:
                        if (tpEmis == TipoEmissao.teSVCAN)// this.cbEmissao.SelectedIndex == 4)
                            throw new Exception("CT-e não dispõe do tipo de contingência SVCAN.");
                        break;

                    case TipoAplicativo.Nfe:
                        if (tpEmis == TipoEmissao.teSVCSP)// this.cbEmissao.SelectedIndex == 3)
                            throw new Exception("NF-e não dispõe do tipo de contingência SCVSP.");
                        break;

                    case TipoAplicativo.MDFe:
                        if (tpEmis != TipoEmissao.teNormal)
                            throw new Exception("MDF-e só dispõe do tipo de emissão Normal.");
                        break;

                    case TipoAplicativo.NFCe:
                        if (tpEmis != TipoEmissao.teNormal)
                            throw new Exception("NFC-e só dispõe do tipo de emissão Normal.");
                        break;
                }

                this.textResultado.Text = "Consultando o servidor. Aguarde....";
                this.textResultado.Update();

                GerarXML oGerar = new GerarXML(Emp);

                int cUF = NFe.Components.Functions.UFParaCodigo(this.comboUf.SelectedValue.ToString());
                int amb = (int)cbAmbiente.SelectedValue;
                string versao = this.cbVersao.SelectedItem.ToString();

                NFe.UI.Formularios.Wait.Show("Consulta a situação do serviço...");

                string XmlNfeDadosMsg = Empresas.Configuracoes[Emp].PastaXmlEnvio + "\\" +
                    oGerar.StatusServico(servico, (int)tpEmis, cUF, amb, versao);

                //Demonstrar o status do serviço
                this.textResultado.Text = VerStatusServico(XmlNfeDadosMsg);
            }
            catch (Exception ex)
            {
                NFe.UI.Formularios.Wait.Close();
                this.textResultado.Text = ex.Message;
            }
        }
Esempio n. 12
0
        private void cmdInutilizar_Click(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;

            string retValidar    = string.Empty;
            string retTransmitir = string.Empty;

            txtResultado.Text = string.Empty;

            GerarXML      geraxml    = new GerarXML();
            TransmitirXML transmitir = new TransmitirXML();
            ValidarXML    validarXml = new ValidarXML();
            AssinarXML    assinar    = new AssinarXML();
            StreamWriter  Grava;

            try
            {
                //Gerando xml
                xmlInut = geraxml.InutilizacaoNFe(Convert.ToInt32(txtNFInicial.Text), Convert.ToInt32(txtNFInicial.Text), p.serienfiscal, "Erro interno do sistema", p.modelo);

                //Assinando xml
                xmlInut_Assinado = assinar.AssinaXML(xmlInut.InnerXml, "infInut", Certificado.getInstance.oCertificado);
            }
            catch (Exception ex)
            {
                Log_Exception.Monta_ArquivoLog(ex);

                txtResultado.AppendText("Erro ao assinar XML: " + ex.Message + Environment.NewLine);
                txtResultado.ForeColor = Color.Maroon;
                this.Cursor            = Cursors.Default;
                return;
            }



            try
            {
                // Validando o XML
                retValidar = validarXml.Valida(xmlInut_Assinado, "Inut");
            }
            catch (Exception ex)
            {
                Log_Exception.Monta_ArquivoLog(ex);

                txtResultado.AppendText("Erro ao validar XML: " + ex.Message + Environment.NewLine);
                txtResultado.ForeColor = Color.Maroon;
                this.Cursor            = Cursors.Default;
                return;
            }


            if (retValidar == string.Empty)
            {
                try
                {
                    //Recebendo xml de retorno da transmissão
                    retTransmitir = transmitir.XML_InutilizacaoNFCe4(xmlInut_Assinado, Certificado.getInstance.oCertificado);


                    if (retTransmitir.Substring(0, 4) != "Erro")
                    {
                        XmlDocument retxml = new XmlDocument();
                        retxml.LoadXml(retTransmitir);

                        //Lote Processado
                        if (retxml.GetElementsByTagName("cStat")[0].InnerText == "102")
                        {
                            try
                            {
                                XMLDao xmlDao = new XMLDao();

                                p.xml.numdoc     = p.numdoc;
                                p.xml.data       = DateTime.Now;
                                p.xml.arquivoXML = retxml.InnerXml;
                                p.xml.Modelo     = p.modelo;
                                p.xml.statNFCe   = "102";

                                if (!string.IsNullOrEmpty(Controle.getInstance.caminho_XMLInutilizado))
                                {
                                    //Salvando o arquivo XML na pasta selecionada no FORM Parametros > aba Arquivos
                                    Grava = File.CreateText(Controle.getInstance.caminho_XMLInutilizado + @"\NOTA " + p.nfiscal + " - INUTILIZADA.xml");
                                    Grava.Write(p.xml.arquivoXML);
                                    Grava.Close();
                                }


                                //Atualizando o status do pedido para inutilizada
                                (new PedidoDao()).Update_StatNFCe_CondDoc(p.numdoc, "102");



                                using (var db = new Database("stringConexao"))
                                {
                                    try
                                    {
                                        db.BeginTransaction();

                                        foreach (PedidoItem pItem in p.lstPedidoItem)
                                        {
                                            db.Update("UPDATE produto " +
                                                      "SET Estoque = Estoque + " + pItem.qtditens * 1 +
                                                      ",ValorVnd = ValorVnd + " + (pItem.valitens * -1).ToString().Replace(",", ".") +
                                                      " WHERE CodPro = " + pItem.codpro);
                                        }

                                        //Boleta cancelada
                                        db.Update("UPDATE Boleta set condicao = 2 where numdoc = " + p.numdoc);


                                        db.CompleteTransaction();
                                    }
                                    catch (Exception)
                                    {
                                        db.AbortTransaction();
                                        MessageBox.Show("Houve um erro inesperado ao atualizar o estoque e cancelar as boletas, informe imediatamente ao administrador do sistema!", "Mensagem de erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
                                        return;
                                    }
                                }


                                txtResultado.AppendText("Nota Fiscal inutilizada com sucesso!");
                                txtResultado.ForeColor = Color.Green;
                            }
                            catch (Exception ex)
                            {
                                Log_Exception.Monta_ArquivoLog(ex);

                                txtResultado.AppendText("Nota Fiscal inutilizada com sucesso, porém houve um erro inesperado, informe ao administrador do sistema!");
                                txtResultado.ForeColor = Color.Maroon;
                            }
                        }
                        else
                        {
                            txtResultado.AppendText("Erro ao transmitir XML (002): " + retxml.GetElementsByTagName("xMotivo")[0].InnerText + Environment.NewLine);
                            txtResultado.ForeColor = Color.Maroon;
                        }
                    }
                    else
                    {
                        txtResultado.AppendText("Erro ao transmitir XML (001): " + retTransmitir + Environment.NewLine);
                        txtResultado.ForeColor = Color.Maroon;
                    }
                }
                catch (Exception ex)
                {
                    Log_Exception.Monta_ArquivoLog(ex);

                    txtResultado.AppendText("Erro ao finalizar XML: " + ex.Message + Environment.NewLine);
                    txtResultado.ForeColor = Color.Maroon;
                }
            }

            this.Cursor = Cursors.Default;
        }
Esempio n. 13
0
        /// <summary>
        /// Envia um arquivo para o webservice da NFE e recebe a resposta.
        /// </summary>
        /// <returns>Retorna uma string com a mensagem obtida do webservice de status do serviço da NFe</returns>
        /// <example>string vPastaArq = this.CriaArqXMLStatusServico();</example>
        /// <by>Wandrey Mundin Ferreira</by>
        /// <date>17/06/2009</date>
        private object EnviaArquivoERecebeResposta(int tipo, string arqXMLRetorno, string arqERRRetorno)
        {
            object vStatus = "Ocorreu uma falha ao tentar obter a situação do serviço junto ao SEFAZ.\r\n\r\n" +
                             "O problema pode ter ocorrido por causa dos seguintes fatores:\r\n\r\n" +
                             "- Problema com o certificado digital\r\n" +
                             "- Necessidade de atualização da cadeia de certificados digitais\r\n" +
                             "- Falha de conexão com a internet\r\n" +
                             "- Falha nos servidores do SEFAZ\r\n\r\n" +
                             "Afirmamos que a produtora do software não se responsabiliza por decisões tomadas e/ou execuções realizadas com base nas informações acima.\r\n\r\n";

            DateTime startTime;
            DateTime stopTime;
            TimeSpan elapsedTime;

            long elapsedMillieconds;

            startTime = DateTime.Now;

            while (true)
            {
                stopTime           = DateTime.Now;
                elapsedTime        = stopTime.Subtract(startTime);
                elapsedMillieconds = (int)elapsedTime.TotalMilliseconds;

                if (elapsedMillieconds >= 120000) //120.000 ms que corresponde á 120 segundos que corresponde a 2 minutos
                {
                    break;
                }

                if (File.Exists(arqXMLRetorno))
                {
                    if (!Auxiliar.FileInUse(arqXMLRetorno))
                    {
                        try
                        {
                            //Ler o status do serviço no XML retornado pelo WebService
                            //XmlTextReader oLerXml = new XmlTextReader(ArqXMLRetorno);

                            try
                            {
                                GerarXML oGerar = new GerarXML(Emp);

                                if (tipo == 1)
                                {
                                    vStatus = ProcessaStatusServico(arqXMLRetorno);
                                }
                                else
                                {
                                    vStatus = oGerar.ProcessaConsultaCadastro(arqXMLRetorno);
                                }
                            }
                            catch (Exception ex)
                            {
                                vStatus = ex.Message;
                                break;
                                //Se não conseguir ler o arquivo vai somente retornar ao loop para tentar novamente, pois
                                //pode ser que o arquivo esteja em uso ainda.
                            }

                            //Detetar o arquivo de retorno
                            try
                            {
                                FileInfo oArquivoDel = new FileInfo(arqXMLRetorno);
                                oArquivoDel.Delete();
                                break;
                            }
                            catch
                            {
                                //Somente deixa fazer o loop novamente e tentar deletar
                            }
                        }
                        catch (Exception ex)
                        {
                            vStatus += ex.Message;
                        }
                    }
                }
                else if (File.Exists(arqERRRetorno))
                {
                    //Retornou um arquivo com a extensão .ERR, ou seja, deu um erro,
                    //futuramente tem que retornar esta mensagem para a MessageBox do usuário.

                    //Detetar o arquivo de retorno
                    try
                    {
                        vStatus += System.IO.File.ReadAllText(arqERRRetorno, Encoding.Default);
                        System.IO.File.Delete(arqERRRetorno);
                        break;
                    }
                    catch
                    {
                        //Somente deixa fazer o loop novamente e tentar deletar
                    }
                }
                Thread.Sleep(3000);
            }

            //Retornar o status do serviço
            return(vStatus);
        }
Esempio n. 14
0
        private void buttonStatusServidor_Click(object sender, EventArgs e)
        {
            this.textResultado.Text = "";
            this.Refresh();

            TipoEmissao    tpEmis  = (TipoEmissao)Enum.Parse(typeof(TipoEmissao), Enum.GetName(typeof(TipoEmissao), ((ComboElem)(new System.Collections.ArrayList(arrTpEmis))[cbEmissao.SelectedIndex]).Codigo));
            TipoAplicativo servico = (TipoAplicativo)cbServico.SelectedIndex;

            if (servico == TipoAplicativo.Cte)
            {
                if (tpEmis == TipoEmissao.teSVCAN)
                {
                    MessageBox.Show("CT-e não dispõe do tipo de contingência SVCAN.", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }
            }
            else if (servico == TipoAplicativo.Nfe)
            {
                if (tpEmis == TipoEmissao.teSVCSP)
                {
                    MessageBox.Show("NF-e não dispõe do tipo de contingência SCVSP.", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }
            }
            else if (servico == TipoAplicativo.MDFe)
            {
                if (tpEmis != TipoEmissao.teNormal)
                {
                    MessageBox.Show("MDF-e só dispõe do tipo de emissão Normal.", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }
            }
            else if (servico == TipoAplicativo.NFCe)
            {
                if (tpEmis != TipoEmissao.teNormal)
                {
                    MessageBox.Show("NFC-e só dispõe do tipo de emissão Normal.", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }
            }

            this.toolStripStatusLabel1.Text = _wait;
            this.Refresh();

            this.Cursor = Cursors.WaitCursor;
            try
            {
                GerarXML oGerar = new GerarXML(Emp);

                int cUF = ((ComboElem)(new System.Collections.ArrayList(arrUF))[comboUf.SelectedIndex]).Codigo;
                int amb = ((ComboElem)(new System.Collections.ArrayList(arrAmb))[cbAmbiente.SelectedIndex]).Codigo;

                string XmlNfeDadosMsg = Empresas.Configuracoes[Emp].PastaXmlEnvio + "\\" + oGerar.StatusServico(servico, (int)tpEmis, cUF, amb, this.cbVersao.SelectedItem.ToString());

                //Demonstrar o status do serviço
                this.textResultado.Text = VerStatusServico(XmlNfeDadosMsg);
            }
            catch (Exception ex)
            {
                this.textResultado.Text = ex.Message;
            }
            finally
            {
                this.Cursor = Cursors.Default;
                this.toolStripStatusLabel1.Text = "";
            }
        }
Esempio n. 15
0
        private void buttonPesquisa_Click(object sender, EventArgs e)
        {
            this.textResultado.Clear();
            this.Refresh();

            try
            {
                TipoAplicativo servico = (TipoAplicativo)cbServico.SelectedValue;
                TipoEmissao    tpEmis  = (TipoEmissao)this.cbEmissao.SelectedValue;

                switch (servico)
                {
                case TipoAplicativo.Cte:
                    if (tpEmis == TipoEmissao.teSVCAN)    // this.cbEmissao.SelectedIndex == 4)
                    {
                        throw new Exception("CT-e não dispõe do tipo de contingência SVCAN.");
                    }
                    break;

                case TipoAplicativo.Nfe:
                    if (tpEmis == TipoEmissao.teSVCSP)    // this.cbEmissao.SelectedIndex == 3)
                    {
                        throw new Exception("NF-e não dispõe do tipo de contingência SCVSP.");
                    }
                    break;

                case TipoAplicativo.MDFe:
                    if (tpEmis != TipoEmissao.teNormal)
                    {
                        throw new Exception("MDF-e só dispõe do tipo de emissão Normal.");
                    }
                    break;

                case TipoAplicativo.NFCe:
                    if (tpEmis != TipoEmissao.teNormal)
                    {
                        throw new Exception("NFC-e só dispõe do tipo de emissão Normal.");
                    }
                    break;
                }

                this.textResultado.Text = "Consultando o servidor. Aguarde....";
                this.textResultado.Update();

                GerarXML oGerar = new GerarXML(Emp);

                int    cUF    = NFe.Components.Functions.UFParaCodigo(this.comboUf.SelectedValue.ToString());
                int    amb    = (int)cbAmbiente.SelectedValue;
                string versao = this.cbVersao.SelectedItem.ToString();

                NFe.UI.Formularios.Wait.Show("Consulta a situação do serviço...");

                string XmlNfeDadosMsg = Empresas.Configuracoes[Emp].PastaXmlEnvio + "\\" +
                                        oGerar.StatusServico(servico, (int)tpEmis, cUF, amb, versao);

                //Demonstrar o status do serviço
                this.textResultado.Text = VerStatusServico(XmlNfeDadosMsg);
            }
            catch (Exception ex)
            {
                NFe.UI.Formularios.Wait.Close();
                this.textResultado.Text = ex.Message;
            }
        }
Esempio n. 16
0
        private const int _Minutos = 12;  //12 minutos para atender o consumo indevido da SEFAZ

        public void Analisar(int emp)
        {
            oAux = new Auxiliar();

            try
            {
                if (string.IsNullOrEmpty(Empresas.Configuracoes[emp].PastaXmlEnviado) || !Directory.Exists(Empresas.Configuracoes[emp].PastaXmlEnviado))
                {
                    return;
                }

                // le todos os arquivos que estão na pasta em processamento
                string[] files = Directory.GetFiles(Empresas.Configuracoes[emp].PastaXmlEnviado + "\\" +
                                                    PastaEnviados.EmProcessamento.ToString()).Where(w => w.EndsWith(Propriedade.Extensao(Propriedade.TipoEnvio.NFe).EnvioXML, StringComparison.InvariantCultureIgnoreCase) ||
                                                                                                    w.EndsWith(Propriedade.Extensao(Propriedade.TipoEnvio.CTe).EnvioXML, StringComparison.InvariantCultureIgnoreCase) ||
                                                                                                    w.EndsWith(Propriedade.Extensao(Propriedade.TipoEnvio.MDFe).EnvioXML, StringComparison.InvariantCultureIgnoreCase)).ToArray <string>();

                // considera os arquivos em que a data do ultimo acesso é superior a 5 minutos
                DateTime UltimaData = DateTime.Now.AddMinutes(-_Minutos);

                foreach (string file in files)
                {
                    if (!Functions.FileInUse(file))
                    {
                        FileInfo fi = new FileInfo(file);

                        //usar a última data de acesso, e não a data de criação
                        if (fi.LastWriteTime <= UltimaData)
                        {
                            if (oLerXml == null)
                            {
                                oLerXml   = new LerXML();
                                oGerarXml = new GerarXML(emp);
                                fluxo     = new FluxoNfe(emp);
                            }

                            try
                            {
                                XmlDocument doc = new XmlDocument();
                                doc.Load(file);

                                TipoAplicativo tipoArquivo = TipoAplicativo.Nfe;
                                string         extNFe      = Propriedade.Extensao(Propriedade.TipoEnvio.NFe).EnvioXML;
                                string         extProcNFe  = Propriedade.ExtRetorno.ProcNFe;
                                string         arquivoSit  = string.Empty;
                                string         chNFe       = string.Empty;

                                switch (doc.DocumentElement.Name)
                                {
                                case "MDFe":
                                    tipoArquivo = TipoAplicativo.MDFe;
                                    extNFe      = Propriedade.Extensao(Propriedade.TipoEnvio.MDFe).EnvioXML;
                                    extProcNFe  = Propriedade.ExtRetorno.ProcMDFe;

                                    oLerXml.Mdfe(doc);
                                    arquivoSit = oLerXml.oDadosNfe.chavenfe.Substring(4);
                                    chNFe      = oLerXml.oDadosNfe.chavenfe.Substring(4);
                                    break;

                                case "NFe":
                                    tipoArquivo = TipoAplicativo.Nfe;
                                    extNFe      = Propriedade.Extensao(Propriedade.TipoEnvio.NFe).EnvioXML;
                                    extProcNFe  = Propriedade.ExtRetorno.ProcNFe;

                                    oLerXml.Nfe(doc);
                                    arquivoSit = oLerXml.oDadosNfe.chavenfe.Substring(3);
                                    chNFe      = oLerXml.oDadosNfe.chavenfe.Substring(3);
                                    break;

                                case "CTe":
                                    tipoArquivo = TipoAplicativo.Cte;
                                    extNFe      = Propriedade.Extensao(Propriedade.TipoEnvio.CTe).EnvioXML;
                                    extProcNFe  = Propriedade.ExtRetorno.ProcCTe;

                                    oLerXml.Cte(doc);
                                    arquivoSit = oLerXml.oDadosNfe.chavenfe.Substring(3);
                                    chNFe      = oLerXml.oDadosNfe.chavenfe.Substring(3);
                                    break;
                                }

                                //Ler a NFe

                                //Verificar se o -nfe.xml existe na pasta de autorizados
                                bool NFeJaNaAutorizada = oAux.EstaAutorizada(file, oLerXml.oDadosNfe.dEmi, extNFe, extNFe);

                                //Verificar se o -procNfe.xml existe na past de autorizados
                                bool procNFeJaNaAutorizada = oAux.EstaAutorizada(file, oLerXml.oDadosNfe.dEmi, extNFe, extProcNFe);

                                //Se um dos XML´s não estiver na pasta de autorizadas ele força finalizar o processo da NFe.
                                if (!NFeJaNaAutorizada || !procNFeJaNaAutorizada)
                                {
                                    //Verificar se a NFe está no fluxo, se não estiver vamos incluir ela para que funcione
                                    //a rotina de gerar o -procNFe.xml corretamente. Wandrey 21/10/2009
                                    if (!fluxo.NfeExiste(oLerXml.oDadosNfe.chavenfe))
                                    {
                                        fluxo.InserirNfeFluxo(oLerXml.oDadosNfe.chavenfe, oLerXml.oDadosNfe.mod, file);
                                    }

                                    //gera um -ped-sit.xml mesmo sendo autorizada ou denegada, pois assim sendo, o ERP precisaria dele
                                    oGerarXml.Consulta(tipoArquivo, arquivoSit + Propriedade.Extensao(Propriedade.TipoEnvio.PedSit).EnvioXML,
                                                       Convert.ToInt32(oLerXml.oDadosNfe.tpAmb),
                                                       Convert.ToInt32(oLerXml.oDadosNfe.tpEmis),
                                                       chNFe,
                                                       oLerXml.oDadosNfe.versao);
                                }
                                else
                                {
                                    //Move o XML da pasta em processamento para a pasta de XML´s com erro (-nfe.xml)
                                    oAux.MoveArqErro(file);

                                    //Move o XML da pasta em processamento para a pasta de XML´s com erro (-procNFe.xml)
                                    oAux.MoveArqErro(Empresas.Configuracoes[emp].PastaXmlEnviado + "\\" + PastaEnviados.EmProcessamento.ToString() + "\\" + Functions.ExtrairNomeArq(file, extNFe) + extProcNFe);

                                    //Tirar a nota fiscal do fluxo
                                    fluxo.ExcluirNfeFluxo(oLerXml.oDadosNfe.chavenfe);
                                }
                            }
                            catch (Exception ex)
                            {
                                try
                                {
                                    // grava o arquivo com extensao .ERR
                                    oAux.GravarArqErroERP(Path.GetFileNameWithoutExtension(file) + ".err", ex.Message);
                                }
                                catch
                                {
                                    //Se deu erro na hora de gravar o erro para o ERP, infelizmente não posso fazer mais nada. Wandrey 28/04/2011
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                try
                {
                    // grava o arquivo generico
                    oAux.GravarArqErroERP(string.Format(Propriedade.NomeArqERRUniNFe, DateTime.Now.ToString("yyyyMMddTHHmmss")), ex.Message);
                }
                catch
                {
                    //Se deu erro na hora de gravar o erro para o ERP, infelizmente não posso fazer mais nada. Wandrey 28/04/2011
                }
            }
        }
Esempio n. 17
0
        /// <summary>
        /// Move arquivos da nota fiscal eletrônica para suas respectivas pastas
        /// </summary>
        /// <param name="Arquivo">Nome do arquivo a ser movido</param>
        /// <param name="PastaXMLEnviado">Pasta de XML´s enviados para onde será movido o arquivo</param>
        /// <param name="SubPastaXMLEnviado">SubPasta de XML´s enviados para onde será movido o arquivo</param>
        /// <param name="PastaBackup">Pasta para Backup dos XML´s enviados</param>
        /// <param name="Emissao">Data de emissão da Nota Fiscal ou Data Atual do envio do XML para separação dos XML´s em subpastas por Ano e Mês</param>
        /// <date>16/07/2008</date>
        /// <by>Wandrey Mundin Ferreira</by>
        public static void MoverArquivo(string arquivo, PastaEnviados subPastaXMLEnviado, DateTime emissao)
        {
            int emp = Empresas.FindEmpresaByThread();

            #region Criar pastas que receberão os arquivos
            //Criar subpastas da pasta dos XML´s enviados
            Empresas.Configuracoes[emp].CriarSubPastaEnviado();

            //Criar Pasta do Mês para gravar arquivos enviados autorizados ou denegados
            string nomePastaEnviado = string.Empty;
            string destinoArquivo = string.Empty;
            switch (subPastaXMLEnviado)
            {
                case PastaEnviados.EmProcessamento:
                    nomePastaEnviado = Empresas.Configuracoes[emp].PastaXmlEnviado + "\\" + PastaEnviados.EmProcessamento.ToString();
                    destinoArquivo = nomePastaEnviado + "\\" + Functions.ExtrairNomeArq(arquivo, ".xml") + ".xml";
                    break;

                case PastaEnviados.Autorizados:
                    nomePastaEnviado = Empresas.Configuracoes[emp].PastaXmlEnviado + "\\" +
                                        PastaEnviados.Autorizados.ToString() + "\\" +
                                        Empresas.Configuracoes[emp].DiretorioSalvarComo.ToString(emissao);
                    destinoArquivo = nomePastaEnviado + Functions.ExtrairNomeArq(arquivo, ".xml") + ".xml";
                    goto default;

                case PastaEnviados.Denegados:
                    nomePastaEnviado = Empresas.Configuracoes[emp].PastaXmlEnviado + "\\" +
                                        PastaEnviados.Denegados.ToString() + "\\" +
                                        Empresas.Configuracoes[emp].DiretorioSalvarComo.ToString(emissao);
                    if (arquivo.ToLower().EndsWith(Propriedade.ExtRetorno.Den))//danasa 11-4-2012
                        destinoArquivo = Path.Combine(nomePastaEnviado, Path.GetFileName(arquivo));
                    else
                        destinoArquivo = Path.Combine(nomePastaEnviado, Functions.ExtrairNomeArq(arquivo, Propriedade.ExtEnvio.Nfe) + Propriedade.ExtRetorno.Den);
                    goto default;

                default:
                    if (!Directory.Exists(nomePastaEnviado))
                    {
                        System.IO.Directory.CreateDirectory(nomePastaEnviado);
                    }
                    break;
            }
            #endregion

            //Se conseguiu criar a pasta ele move o arquivo, caso contrário
            if (Directory.Exists(nomePastaEnviado))
            {
                #region Mover o XML para a pasta de XML´s enviados
                //Se for para mover para a Pasta EmProcessamento
                if (subPastaXMLEnviado == PastaEnviados.EmProcessamento)
                {
                    //Se já existir o arquivo na pasta EmProcessamento vamos mover 
                    //ele para a pasta com erro antes para evitar exceção. Wandrey 05/07/2011
                    if (File.Exists(destinoArquivo))
                    {
                        string destinoErro = Empresas.Configuracoes[emp].PastaXmlErro + "\\" + Functions.ExtrairNomeArq(arquivo, ".xml") + ".xml";
                        File.Move(destinoArquivo, destinoErro);

                        //danasa 11-4-2012
                        Auxiliar.WriteLog("Arquivo \"" + destinoArquivo + "\" movido para a pasta \"" + Empresas.Configuracoes[emp].PastaXmlErro + "\".", true);
                    }
                    File.Move(arquivo, destinoArquivo);
                }
                else
                {
                    //Se já existir o arquivo na pasta autorizados ou denegado, não vou mover o novo arquivo para lá, pois posso estar sobrepondo algum arquivo importante
                    //Sendo assim se o usuário quiser forçar mover, tem que deletar da pasta autorizados ou denegados manualmente, com isso evitamos perder um XML importante.
                    //Wandrey 05/07/2011
                    if (!File.Exists(destinoArquivo))
                    {
                        File.Move(arquivo, destinoArquivo);
                    }
                    else
                    {
                        string destinoErro = Empresas.Configuracoes[emp].PastaXmlErro + "\\" + Functions.ExtrairNomeArq(arquivo, ".xml") + ".xml";
                        File.Move(arquivo, destinoErro);

                        //danasa 11-4-2012
                        Auxiliar.WriteLog("Arquivo \"" + arquivo + "\" movido para a pasta \"" + Empresas.Configuracoes[emp].PastaXmlErro + "\".", true);
                    }
                }
                #endregion

                if (subPastaXMLEnviado == PastaEnviados.Autorizados || subPastaXMLEnviado == PastaEnviados.Denegados)
                {
                    #region Copiar XML para a pasta de BACKUP
                    //Fazer um backup do XML que foi copiado para a pasta de enviados
                    //para uma outra pasta para termos uma maior segurança no arquivamento
                    //Normalmente esta pasta é em um outro computador ou HD
                    if (Empresas.Configuracoes[emp].PastaBackup.Trim() != "")
                    {
                        //Criar Pasta do Mês para gravar arquivos enviados
                        string nomePastaBackup = string.Empty;
                        switch (subPastaXMLEnviado)
                        {
                            case PastaEnviados.Autorizados:
                                nomePastaBackup = Empresas.Configuracoes[emp].PastaBackup + "\\" +
                                                    PastaEnviados.Autorizados + "\\" +
                                                    Empresas.Configuracoes[emp].DiretorioSalvarComo.ToString(emissao);
                                goto default;

                            case PastaEnviados.Denegados:
                                nomePastaBackup = Empresas.Configuracoes[emp].PastaBackup + "\\" +
                                                    PastaEnviados.Denegados + "\\" +
                                                    Empresas.Configuracoes[emp].DiretorioSalvarComo.ToString(emissao);
                                goto default;

                            default:
                                if (!Directory.Exists(nomePastaBackup))
                                {
                                    System.IO.Directory.CreateDirectory(nomePastaBackup);
                                }
                                break;
                        }

                        //Se conseguiu criar a pasta ele move o arquivo, caso contrário
                        if (Directory.Exists(nomePastaBackup))
                        {
                            //Mover o arquivo da nota fiscal para a pasta de backup
                            string destinoBackup = nomePastaBackup + Functions.ExtrairNomeArq(arquivo, ".xml") + ".xml";
                            if (File.Exists(destinoBackup))
                            {
                                File.Delete(destinoBackup);
                            }
                            File.Copy(destinoArquivo, destinoBackup);
                        }
                        else
                        {
                            throw new Exception("Pasta de backup informada nas configurações não existe. (Pasta: " + nomePastaBackup + ")");
                        }
                    }
                    #endregion

                    #region Copiar o XML para a pasta do DanfeMon, se configurado para isso
                    CopiarXMLPastaDanfeMon(destinoArquivo);
                    #endregion

                    #region Copiar o XML para o FTP
                    GerarXML oGerarXML = new GerarXML(emp);
                    oGerarXML.XmlParaFTP(emp, destinoArquivo);
                    #endregion
                }
            }
            else
            {
                throw new Exception("Pasta para arquivamento dos XML´s enviados não existe. (Pasta: " + nomePastaEnviado + ")");
            }
        }
        private void CmdCancela_Click(object sender, EventArgs e)
        {
            if ((DateTime.Now - p.datadigitacao).TotalHours > 24)
            {
                MessageBox.Show("Prazo de Cancelamento Superior ao Previsto na Legislação.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (p.conddoc == "C")
            {
                MessageBox.Show("NF-e já cancelada.", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            if (cboMotivo.Text.Trim().Length < 15)
            {
                MessageBox.Show("Minimo de 15 caracteres!", "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            this.Cursor = Cursors.WaitCursor;

            StreamWriter  Grava;
            GerarXML      geraxml    = new GerarXML();
            AssinarXML    assinar    = new AssinarXML();
            ValidarXML    validar    = new ValidarXML();
            TransmitirXML transmitir = new TransmitirXML();
            XMLDao        xmldao     = new XMLDao();

            string retValidar    = string.Empty;
            string xMotivo       = cboMotivo.Text;
            string retTransmitir = string.Empty;

            txtResultado.Text = string.Empty;

            try
            {
                //Gerando xml
                xmlCanc = geraxml.CancelamentoNFe(p, xMotivo);

                //Assinando xml
                xmlCanc_Assinado = assinar.AssinaXML(xmlCanc.InnerXml, "infEvento", Certificado.getInstance.oCertificado);
            }
            catch (Exception ex)
            {
                Log_Exception.Monta_ArquivoLog(ex);

                MessageBox.Show("Erro ao assinar: " + ex.Message, "Mensagem", MessageBoxButtons.OK);
                this.Cursor = Cursors.Default;
                return;
            }

            try
            {
                //Validando o xml assinado
                retValidar = validar.Valida(xmlCanc_Assinado, "Canc");
            }
            catch (Exception ex)
            {
                Log_Exception.Monta_ArquivoLog(ex);

                MessageBox.Show("Erro ao Validar: " + ex.Message, "Mensagem", MessageBoxButtons.OK);
                this.Cursor = Cursors.Default;
                return;
            }


            if (retValidar == string.Empty)
            {
                try
                {
                    //Recebendo xml de retorno da transmissão
                    retTransmitir = transmitir.XML_CancelamentoNFCe4(xmlCanc_Assinado, p.nfiscal, Certificado.getInstance.oCertificado);

                    if (retTransmitir.Substring(0, 4) != "Erro")
                    {
                        XmlDocument xmlRetorno = new XmlDocument();
                        xmlRetorno.LoadXml(retTransmitir);

                        //Lote processado
                        if (xmlRetorno.GetElementsByTagName("cStat")[0].InnerText == "128")
                        {
                            //Evento registrado e vinculado a NFC-e
                            if (xmlRetorno.GetElementsByTagName("cStat")[1].InnerText == "135")
                            {
                                try
                                {
                                    p.xml.numdoc     = p.numdoc;
                                    p.xml.data       = DateTime.Now;
                                    p.xml.arquivoXML = xmlRetorno.InnerXml;
                                    p.xml.Modelo     = p.modelo;
                                    p.xml.statNFCe   = "135";


                                    if (!string.IsNullOrEmpty(Controle.getInstance.caminho_XMLCancelado))
                                    {
                                        //Salva o arquivo XML na pasta
                                        Grava = File.CreateText(Controle.getInstance.caminho_XMLCancelado + @"\110111-" + p.chave + "-1-procEventoNfe.xml");
                                        Grava.Write(p.xml.arquivoXML);
                                        Grava.Close();
                                    }

                                    //Salva arquivo XML no Banco SQL (NFe)
                                    if (xmldao.Grava_XML(p.xml))
                                    {
                                        //Atualizando o status do pedido para cancelada (135)
                                        (new PedidoDao()).Update_StatNFCe_CondDoc(p.numdoc, p.xml.statNFCe);


                                        var db = new Database("stringConexao");

                                        try
                                        {
                                            db.BeginTransaction();

                                            foreach (PedidoItem pItem in p.lstPedidoItem)
                                            {
                                                db.Update("UPDATE produto " +
                                                          "SET Estoque = Estoque + " + pItem.qtditens * 1 +
                                                          ",ValorVnd = ValorVnd + " + (pItem.valitens * -1).ToString().Replace(",", ".") +
                                                          " WHERE CodPro = " + pItem.codpro);
                                            }

                                            //Boleta cancelada
                                            db.Update("UPDATE Boleta set condicao = 2 where numdoc = " + p.numdoc);


                                            db.CompleteTransaction();
                                        }
                                        catch (Exception)
                                        {
                                            db.AbortTransaction();
                                            MessageBox.Show("Houve um erro inesperado ao atualizar o estoque e cancelar as boletas, informe imediatamente ao administrador do sistema!", "Mensagem de erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
                                            return;
                                        }


                                        txtResultado.AppendText("Pedido cancelado com sucesso!");
                                        txtResultado.ForeColor = Color.Green;
                                    }
                                    else
                                    {
                                        txtResultado.AppendText("Pedido cancelado com sucesso, porém houve um erro ao salvar o arquivo XML no banco de dados, informe ao administrador do sistema!");
                                        txtResultado.ForeColor = Color.Green;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    Log_Exception.Monta_ArquivoLog(ex);

                                    txtResultado.AppendText("Pedido cancelado com sucesso, porém houve um erro inesperado, informe ao administrador do sistema!");
                                    txtResultado.ForeColor = Color.Green;
                                }
                            }
                            else
                            {
                                txtResultado.AppendText("Erro ao cancelar (002): " + xmlRetorno.GetElementsByTagName("xMotivo")[1].InnerText + Environment.NewLine);
                                txtResultado.ForeColor = Color.Maroon;
                                this.Cursor            = Cursors.Default;
                                return;
                            }
                        }
                        else
                        {
                            txtResultado.AppendText("Erro ao cancelar (001): " + xmlRetorno.GetElementsByTagName("xMotivo")[0].InnerText + Environment.NewLine);
                            txtResultado.ForeColor = Color.Maroon;
                            this.Cursor            = Cursors.Default;
                            return;
                        }
                    }
                    else
                    {
                        txtResultado.AppendText("Erro ao transmitir (001): " + retTransmitir + Environment.NewLine);
                        txtResultado.ForeColor = Color.Maroon;
                        this.Cursor            = Cursors.Default;
                        return;
                    }
                }
                catch (Exception ex)
                {
                    Log_Exception.Monta_ArquivoLog(ex);

                    MessageBox.Show("Erro ao Transmitir XML: " + ex.Message, "Mensagem", MessageBoxButtons.OK);
                    this.Cursor = Cursors.Default;
                    return;
                }
            }
            else
            {
                txtResultado.AppendText("Erro na validação do XML: " + retValidar + Environment.NewLine);
                txtResultado.ForeColor = Color.Maroon;
                this.Cursor            = Cursors.Default;
                return;
            }

            this.Cursor = Cursors.Default;
        }
Esempio n. 19
0
        private const int _Minutos = 12;  //12 minutos para atender o consumo indevido da SEFAZ

        public void Analisar(int emp)
        {
            this.oAux = new Auxiliar();

            try
            {
                // le todos os arquivos que estão na pasta em processamento
                //                string[] files = Directory.GetFiles(Empresas.Configuracoes[emp].PastaEnviado + "\\" + PastaEnviados.EmProcessamento.ToString(),
                //                                                "*" + Propriedade.ExtEnvio.Nfe,
                //                                                SearchOption.TopDirectoryOnly);

                string[] files = Directory.GetFiles(Empresas.Configuracoes[emp].PastaXmlEnviado + "\\" + PastaEnviados.EmProcessamento.ToString()).Where(w => w.EndsWith(Propriedade.ExtEnvio.Nfe, StringComparison.InvariantCultureIgnoreCase) ||
                                                                                                                                                          w.EndsWith(Propriedade.ExtEnvio.Cte, StringComparison.InvariantCultureIgnoreCase) ||
                                                                                                                                                          w.EndsWith(Propriedade.ExtEnvio.MDFe, StringComparison.InvariantCultureIgnoreCase)).ToArray<string>();

                // considera os arquivos em que a data do ultimo acesso é superior a 5 minutos
                DateTime UltimaData = DateTime.Now.AddMinutes(-_Minutos);

                foreach (string file in files)
                {
                    if (!Functions.FileInUse(file))
                    {
                        FileInfo fi = new FileInfo(file);

                        //usar a última data de acesso, e não a data de criação
                        if (fi.LastWriteTime <= UltimaData)
                        {
                            if (this.oLerXml == null)
                            {
                                this.oLerXml = new LerXML();
                                this.oGerarXml = new GerarXML(emp);
                                this.fluxo = new FluxoNfe(emp);
                            }

                            try
                            {
                                XmlDocument doc = new XmlDocument();
                                doc.Load(file);

                                TipoAplicativo tipoArquivo = TipoAplicativo.Nfe;
                                string extNFe = Propriedade.ExtEnvio.Nfe;
                                string extProcNFe = Propriedade.ExtRetorno.ProcNFe;
                                string arquivoSit = string.Empty;
                                string chNFe = string.Empty;

                                switch (doc.DocumentElement.Name)
                                {
                                    case "MDFe":
                                        tipoArquivo = TipoAplicativo.MDFe;
                                        extNFe = Propriedade.ExtEnvio.MDFe;
                                        extProcNFe = Propriedade.ExtRetorno.ProcMDFe;

                                        oLerXml.Mdfe(file);
                                        arquivoSit = oLerXml.oDadosNfe.chavenfe.Substring(4);
                                        chNFe = oLerXml.oDadosNfe.chavenfe.Substring(4);
                                        break;

                                    case "NFe":
                                        tipoArquivo = TipoAplicativo.Nfe;
                                        extNFe = Propriedade.ExtEnvio.Nfe;
                                        extProcNFe = Propriedade.ExtRetorno.ProcNFe;

                                        oLerXml.Nfe(file);
                                        arquivoSit = oLerXml.oDadosNfe.chavenfe.Substring(3);
                                        chNFe = oLerXml.oDadosNfe.chavenfe.Substring(3);
                                        break;

                                    case "CTe":
                                        tipoArquivo = TipoAplicativo.Cte;
                                        extNFe = Propriedade.ExtEnvio.Cte;
                                        extProcNFe = Propriedade.ExtRetorno.ProcCTe;

                                        oLerXml.Cte(file);
                                        arquivoSit = oLerXml.oDadosNfe.chavenfe.Substring(3);
                                        chNFe = oLerXml.oDadosNfe.chavenfe.Substring(3);
                                        break;
                                }

                                //Ler a NFe

                                //Verificar se o -nfe.xml existe na pasta de autorizados
                                bool NFeJaNaAutorizada = oAux.EstaAutorizada(file, oLerXml.oDadosNfe.dEmi, extNFe, extNFe);

                                //Verificar se o -procNfe.xml existe na past de autorizados
                                bool procNFeJaNaAutorizada = oAux.EstaAutorizada(file, oLerXml.oDadosNfe.dEmi, extNFe, extProcNFe);

                                //Se um dos XML´s não estiver na pasta de autorizadas ele força finalizar o processo da NFe.
                                if (!NFeJaNaAutorizada || !procNFeJaNaAutorizada)
                                {
                                    //Verificar se a NFe está no fluxo, se não estiver vamos incluir ela para que funcione
                                    //a rotina de gerar o -procNFe.xml corretamente. Wandrey 21/10/2009
                                    if (!fluxo.NfeExiste(oLerXml.oDadosNfe.chavenfe))
                                    {
                                        fluxo.InserirNfeFluxo(oLerXml.oDadosNfe.chavenfe, oLerXml.oDadosNfe.mod, file);
                                    }

                                    //gera um -ped-sit.xml mesmo sendo autorizada ou denegada, pois assim sendo, o ERP precisaria dele
                                    oGerarXml.Consulta(tipoArquivo, arquivoSit + Propriedade.ExtEnvio.PedSit_XML,
                                        Convert.ToInt32(oLerXml.oDadosNfe.tpAmb),
                                        Convert.ToInt32(oLerXml.oDadosNfe.tpEmis),
                                        chNFe,
                                        oLerXml.oDadosNfe.versao);
                                }
                                else
                                {
                                    //Move o XML da pasta em processamento para a pasta de XML´s com erro (-nfe.xml)
                                    oAux.MoveArqErro(file);

                                    //Move o XML da pasta em processamento para a pasta de XML´s com erro (-procNFe.xml)
                                    oAux.MoveArqErro(Empresas.Configuracoes[emp].PastaXmlEnviado + "\\" + PastaEnviados.EmProcessamento.ToString() + "\\" + Functions.ExtrairNomeArq(file, extNFe) + extProcNFe);

                                    //Tirar a nota fiscal do fluxo
                                    fluxo.ExcluirNfeFluxo(oLerXml.oDadosNfe.chavenfe);
                                }
                            }
                            catch (Exception ex)
                            {
                                try
                                {
                                    // grava o arquivo com extensao .ERR 
                                    oAux.GravarArqErroERP(Path.GetFileNameWithoutExtension(file) + ".err", ex.Message);
                                }
                                catch
                                {
                                    //Se deu erro na hora de gravar o erro para o ERP, infelizmente não posso fazer mais nada. Wandrey 28/04/2011
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                try
                {
                    // grava o arquivo generico 
                    oAux.GravarArqErroERP(string.Format(Propriedade.NomeArqERRUniNFe, DateTime.Now.ToString("yyyyMMddTHHmmss")), ex.Message);
                }
                catch
                {
                    //Se deu erro na hora de gravar o erro para o ERP, infelizmente não posso fazer mais nada. Wandrey 28/04/2011
                }
            }
        }
Esempio n. 20
0
        /// <summary>
        /// Envia um arquivo para o webservice da NFE e recebe a resposta.
        /// </summary>
        /// <returns>Retorna uma string com a mensagem obtida do webservice de status do serviço da NFe</returns>
        /// <example>string vPastaArq = this.CriaArqXMLStatusServico();</example>
        /// <by>Wandrey Mundin Ferreira</by>
        /// <date>17/06/2009</date>
        private object EnviaArquivoERecebeResposta(string arqXMLRetorno, string arqERRRetorno)
        {
            DateTime startTime;
            DateTime stopTime;
            TimeSpan elapsedTime;

            long elapsedMillieconds;

            startTime = DateTime.Now;

            object vStatus = uninfeDummy.vStatus;

            while (true)
            {
                stopTime           = DateTime.Now;
                elapsedTime        = stopTime.Subtract(startTime);
                elapsedMillieconds = (int)elapsedTime.TotalMilliseconds;

                if (elapsedMillieconds >= 60000)
                {
                    break;
                }

                if (File.Exists(arqXMLRetorno))
                {
                    if (!Functions.FileInUse(arqXMLRetorno))
                    {
                        try
                        {
                            //Ler o status do serviço no XML retornado pelo WebService
                            try
                            {
                                vStatus = new GerarXML(Emp).ProcessaConsultaCadastro(arqXMLRetorno);
                            }
                            catch (Exception ex)
                            {
                                vStatus = ex.Message;
                                break;
                                //Se não conseguir ler o arquivo vai somente retornar ao loop para tentar novamente, pois
                                //pode ser que o arquivo esteja em uso ainda.
                            }

                            //Detetar o arquivo de retorno
                            try
                            {
                                FileInfo oArquivoDel = new FileInfo(arqXMLRetorno);
                                oArquivoDel.Delete();
                                break;
                            }
                            catch
                            {
                                //Somente deixa fazer o loop novamente e tentar deletar
                            }
                        }
                        catch
                        {
                        }
                    }
                }
                else if (File.Exists(arqERRRetorno))
                {
                    //Retornou um arquivo com a extensão .ERR, ou seja, deu um erro,
                    //futuramente tem que retornar esta mensagem para a MessageBox do usuário.

                    //Detetar o arquivo de retorno
                    try
                    {
                        vStatus += System.IO.File.ReadAllText(arqERRRetorno, Encoding.Default);
                        System.IO.File.Delete(arqERRRetorno);
                        break;
                    }
                    catch
                    {
                        //Somente deixa fazer o loop novamente e tentar deletar
                    }
                }

                Thread.Sleep(100);
            }
            //Retornar o status do serviço
            return(vStatus);
        }
Esempio n. 21
0
        // ========================================================================
        private bool Gera_NFCe(Pedido pedido)
        {
            var msg = new StringBuilder();

            XmlDocument xmlNFe          = new XmlDocument();
            XmlDocument xmlNFe_Assinado = new XmlDocument();

            GerarXML      gerarXml      = new GerarXML();
            AssinarXML    assinarXml    = new AssinarXML();
            ValidarXML    validarXml    = new ValidarXML();
            TransmitirXML transmitirXml = new TransmitirXML();
            Email         email         = new Email();
            XMLDao        xmlDao        = new XMLDao();

            StreamWriter Grava;

            string retValidar;
            string strProc;
            string strXmlProcNfe;
            string retTransmitir;
            string cStatus_LoteProcessado;
            string cStatus_Autorizado;

            int nPosI;
            int nPosF;

            try
            {
                retTransmitir = string.Empty;
                retValidar    = string.Empty;

                cStatus_LoteProcessado = string.Empty;
                cStatus_Autorizado     = string.Empty;

                try
                {
                    // Gerando o XML
                    xmlNFe = (gerarXml.NFe(pedido));

                    //MensagemSistema("Arquivo Gerado ...", Color.OliveDrab);

                    // Assinando o XML
                    xmlNFe_Assinado = assinarXml.AssinaXML(xmlNFe.InnerXml, "infNFe", Certificado.getInstance.oCertificado);
                }
                catch (Exception ex)
                {
                    MessageBox.Show("** Erro ao ASSINAR XML NFC-e, tente novamente **" + Environment.NewLine + ex.Message, "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return(false);
                }


                try
                {
                    // Validando o XML
                    retValidar = validarXml.Valida(xmlNFe_Assinado, "NFe");

                    //Inserindo a URL QRCode no xml já assinado
                    xmlNFe_Assinado.LoadXml(xmlNFe_Assinado.InnerXml.Replace("</infNFe>", "</infNFe><infNFeSupl><qrCode><![CDATA[" +
                                                                             gerarXml.Gera_Url_QRCode(xmlNFe_Assinado, pedido) + "]]></qrCode><urlChave>http://www4.fazenda.rj.gov.br/consultaNFCe/QRCode</urlChave></infNFeSupl>"));
                }
                catch (Exception ex)
                {
                    //Log_Exception.Monta_ArquivoLog(ex);
                    MessageBox.Show("** Erro ao VALIDAR XML NFC-e **" + Environment.NewLine + ex.Message, "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return(false);
                }

                if (retValidar == string.Empty)
                {
                    try
                    {
                        //MensagemSistema("Enviando a NFC-e", Color.OliveDrab);

                        // Recebendo o XML de retorno da transmissão
                        retTransmitir = transmitirXml.XML_NFCe4(xmlNFe_Assinado, pedido.nfiscal, Certificado.getInstance.oCertificado);

                        if (retTransmitir.Substring(0, 4) != "Erro")
                        {
                            XmlDocument xmlRetorno = new XmlDocument();
                            xmlRetorno.LoadXml(retTransmitir);

                            // Lote processado
                            if (xmlRetorno.GetElementsByTagName("cStat")[0].InnerText == "104")
                            {
                                // Autorizado
                                if (xmlRetorno.GetElementsByTagName("cStat")[1].InnerText == "100")
                                {
                                    try
                                    {
                                        //MensagemSistema("Autorizado o uso da NFC-e", Color.OliveDrab);

                                        pedido.chave     = xmlRetorno.GetElementsByTagName("chNFe")[0].InnerText;
                                        pedido.protocolo = xmlRetorno.GetElementsByTagName("nProt")[0].InnerText;

                                        // Separar somente o conteúdo a partir da tag <protNFe> até </protNFe>
                                        nPosI   = retTransmitir.IndexOf("<protNFe");
                                        nPosF   = retTransmitir.Length - (nPosI + 13);
                                        strProc = retTransmitir.Substring(nPosI, nPosF);

                                        // XML pronto para salvar
                                        strXmlProcNfe = @"<?xml version=""1.0"" encoding=""utf-8"" ?><nfeProc xmlns=""http://www.portalfiscal.inf.br/nfe"" versao=""4.0"">" + xmlNFe_Assinado.InnerXml + strProc + "</nfeProc>";

                                        pedido.xml = new XML
                                        {
                                            numdoc     = pedido.numdoc,
                                            arquivoXML = strXmlProcNfe,
                                            data       = DateTime.Now,
                                            Modelo     = pedido.modelo,
                                            statNFCe   = "100"
                                        };


                                        //Salva arquivo XML no Banco SQL (NFe)
                                        if (xmlDao.Grava_XML(pedido.xml))
                                        {
                                            // Atualizando o pedido com a Chave, Protocolo, e statNFCe
                                            if ((new PedidoDao()).Update_ChaveProtocolo_condDoc_StatNFCe(pedido.numdoc, pedido.chave, pedido.protocolo, pedido.xml.statNFCe))
                                            {
                                                if (GerarXML.str_Ambiente == "1")
                                                {
                                                    if (!string.IsNullOrEmpty(Controle.getInstance.caminho_XMLAutorizado))
                                                    {
                                                        //Salvando o arquivo XML na pasta
                                                        Grava = File.CreateText(Controle.getInstance.caminho_XMLAutorizado.Remove(Controle.getInstance.caminho_XMLAutorizado.Length - 1) + DateTime.Now.Month + @"\" + pedido.chave + "-procNfe.xml");
                                                        Grava.Write(pedido.xml.arquivoXML);
                                                        Grava.Close();
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        MessageBox.Show("** NOTA EMITIDA **, mas houve um erro inesperado" + Environment.NewLine + ex.Message, "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Error);
                                        return(false);
                                    }
                                }
                                else
                                {
                                    //MessageBox.Show("Erro ao Transmitir(004) XML NFC-e" + Environment.NewLine + xmlRetorno.GetElementsByTagName("xMotivo")[1].InnerText, "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Error);


                                    msg.Append("** NOTA EMITIDA **, mas houve um erro inesperado");
                                    msg.Append(Environment.NewLine);
                                    msg.Append(xmlRetorno.GetElementsByTagName("xMotivo")[1].InnerText);

                                    txtErro.Visible   = true;
                                    btnEmitir.Visible = true;

                                    txtErro.Text = msg.ToString();

                                    msg.Clear();

                                    return(false);
                                }
                            }
                            else
                            {
                                //MessageBox.Show("Erro ao Transmitir(003) XML NFC-e" + Environment.NewLine + xmlRetorno.GetElementsByTagName("xMotivo")[0].InnerText, "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Error);

                                msg.Append("** Erro ao Transmitir(003) XML NFC-e**");
                                msg.Append(Environment.NewLine);
                                msg.Append(xmlRetorno.GetElementsByTagName("xMotivo")[0].InnerText);

                                txtErro.Visible   = true;
                                btnEmitir.Visible = true;

                                txtErro.Text = msg.ToString();

                                msg.Clear();


                                return(false);
                            }
                        }
                        else
                        {
                            //MessageBox.Show("Erro ao Transmitir(002) XML NFC-e" + Environment.NewLine + retTransmitir, "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Error);

                            msg.Append("** Erro ao Transmitir(002) XML NFC-e **");
                            msg.Append(Environment.NewLine);
                            msg.Append(retTransmitir);

                            txtErro.Visible   = true;
                            btnEmitir.Visible = true;

                            txtErro.Text = msg.ToString();

                            msg.Clear();


                            return(false);
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show("Erro ao Transmitir(001) XML NFC-e" + Environment.NewLine + ex.Message, "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return(false);
                    }
                }
                else
                {
                    MessageBox.Show("Erro ao validar XML NFC-e" + Environment.NewLine + retValidar, "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return(false);
                }
            }
            catch (Exception ex)
            {
                Log_Exception.Monta_ArquivoLog(ex);
                MessageBox.Show("Ocorreu um erro inesperado, informe ao administrador do sistema!" + Environment.NewLine + ex.Message, "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(false);
            }

            return(true);
        }