MoveArqErro() public method

Move arquivos XML com erro para uma pasta de xml´s com erro configurados no UniNFe.
public MoveArqErro ( string Arquivo ) : void
Arquivo string
return void
Example #1
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
                }
            }
        }
Example #2
0
        public ConverterTXT(string arquivo)
        {
            Auxiliar oAux = new Auxiliar();

            NFe.ConvertTxt.ConversaoTXT oUniTxtToXml = new NFe.ConvertTxt.ConversaoTXT();

            string pasta = new FileInfo(arquivo).DirectoryName;
            pasta = pasta.Substring(0, pasta.Length - 5); //Retirar a pasta \Temp do final - Wandrey 03/08/2011

            string ccMessage = string.Empty;
            string ccExtension = "-nfe.err";

            try
            {
                int emp = Empresas.FindEmpresaByThread();

                ///
                /// exclui o arquivo de erro
                /// 
                Functions.DeletarArquivo(Empresas.Configuracoes[emp].PastaXmlRetorno + "\\" + Path.GetFileName(Functions.ExtrairNomeArq(arquivo, Propriedade.ExtEnvio.Nfe_TXT) + ccExtension));
                Functions.DeletarArquivo(Empresas.Configuracoes[emp].PastaXmlRetorno + "\\" + Path.GetFileName(Functions.ExtrairNomeArq(arquivo, Propriedade.ExtEnvio.Nfe_TXT) + "-nfe-ret.xml"));
                Functions.DeletarArquivo(Empresas.Configuracoes[emp].PastaXmlErro + "\\" + Path.GetFileName(arquivo));
                ///
                /// exclui o arquivo TXT original
                /// 
                Functions.DeletarArquivo(Empresas.Configuracoes[emp].PastaXmlRetorno + "\\" + Path.GetFileNameWithoutExtension(arquivo) + "-orig.txt");

                ///
                /// processa a conversão
                /// 
                oUniTxtToXml.Converter(arquivo, pasta);//Empresas.Configuracoes[emp].PastaRetorno);

                //Deu tudo certo com a conversão?
                if (string.IsNullOrEmpty(oUniTxtToXml.cMensagemErro))
                {
                    ///
                    /// danasa 8-2009
                    /// 
                    if (oUniTxtToXml.cRetorno.Count == 0)
                    {
                        ccMessage = "cStat=02\r\n" +
                            "xMotivo=Falha na conversão. Sem informações para converter o arquivo texto";

                        oAux.MoveArqErro(arquivo, ".txt");
                    }
                    else
                    {
                        //
                        // salva o arquivo texto original
                        //
                        if (pasta.ToLower().Equals(Empresas.Configuracoes[emp].PastaXmlEnvio.ToLower()) || pasta.ToLower().Equals(Empresas.Configuracoes[emp].PastaValidar.ToLower()))
                        {
                            FileInfo ArqOrig = new FileInfo(arquivo);

                            string vvNomeArquivoDestino = Empresas.Configuracoes[emp].PastaXmlRetorno + "\\" + Path.GetFileNameWithoutExtension(arquivo) + "-orig.txt";
                            ArqOrig.MoveTo(vvNomeArquivoDestino);
                        }
                        ccExtension = "-nfe.txt";
                        ccMessage = "cStat=01\r\n" +
                            "xMotivo=Convertido com sucesso. Foi(ram) convertida(s) " + oUniTxtToXml.cRetorno.Count.ToString() + " nota(s) fiscal(is)";

                        foreach (NFe.ConvertTxt.txtTOxmlClassRetorno txtClass in oUniTxtToXml.cRetorno)
                        {
                            ///
                            /// monta o texto que será gravado no arquivo de aviso ao ERP
                            /// 
                            ccMessage += Environment.NewLine +
                                    "Nota fiscal: " + txtClass.NotaFiscal.ToString("000000000") +
                                    " Série: " + txtClass.Serie.ToString("000") +
                                    " - ChaveNFe: " + txtClass.ChaveNFe;

                            // move o arquivo XML criado na pasta Envio\Convertidos para a pasta Envio
                            // ou
                            // move o arquivo XML criado na pasta Validar\Convertidos para a pasta Validar
                            string nomeArquivoDestino = Path.Combine(pasta, Path.GetFileName(txtClass.XMLFileName));
                            Functions.Move(txtClass.XMLFileName, nomeArquivoDestino);

                            Functions.DeletarArquivo(Empresas.Configuracoes[emp].PastaXmlErro + "\\" + txtClass.ChaveNFe + Propriedade.ExtEnvio.Nfe);
                        }
                    }
                }
                else
                {
                    ///
                    /// danasa 8-2009
                    /// 
                    ccMessage = "cStat=99\r\n" +
                        "xMotivo=Falha na conversão\r\n" +
                        "MensagemErro=" + oUniTxtToXml.cMensagemErro;
                }
            }
            catch (Exception ex)
            {
                ccMessage = ex.Message;
                ccExtension = "-nfe.err";
            }

            if (!string.IsNullOrEmpty(ccMessage))
            {
                oAux.MoveArqErro(arquivo, ".txt");

                if (ccMessage.StartsWith("cStat=02") || ccMessage.StartsWith("cStat=99"))
                {
                    ///
                    /// exclui todos os XML gerados na pasta Envio\convertidos somente se houve erro na conversão
                    /// 
                    foreach (NFe.ConvertTxt.txtTOxmlClassRetorno txtClass in oUniTxtToXml.cRetorno)
                    {
                        Functions.DeletarArquivo(pasta + "\\convertidos\\" + Path.GetFileName(txtClass.XMLFileName));
                    }
                }
                ///
                /// danasa 8-2009
                /// 
                /// Gravar o retorno para o ERP em formato TXT com o erro ocorrido
                /// 
                oAux.GravarArqErroERP(Functions.ExtrairNomeArq(arquivo, Propriedade.ExtEnvio.Nfe_TXT) + ccExtension, ccMessage);
            }
        }
Example #3
0
        /// <summary>
        /// Criar uma lista com os recibos a serem consultados no servidor do SEFAZ
        /// </summary>
        /// <returns>Lista dos recibos</returns>
        /// <by>Wandrey Mundin Ferreira</by>
        public List<ReciboCons> CriarListaRec()
        {
            CriarXml(true);

            List<ReciboCons> lstRecibo = new List<ReciboCons>();
            List<string> lstNumRec = new List<string>();

            DateTime startTime;
            DateTime stopTime;
            TimeSpan elapsedTime;

            long elapsedMillieconds;
            startTime = DateTime.Now;

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

                try
                {
                    lock (Smf.Fluxo)
                    {
                        XmlDocument doc = new XmlDocument(); //Criar instância do XmlDocument Class
                        fsArquivo = OpenFileFluxo(false);
                        doc.Load(fsArquivo); //Carregar o arquivo aberto no XmlDocument
                        fsArquivo.Close();

                        XmlNodeList documentoList = doc.GetElementsByTagName(ElementoFixo.Documento.ToString()); //Pesquisar o elemento Documento no arquivo XML
                        foreach (XmlNode documentoNode in documentoList)
                        {
                            XmlElement documentoElemento = (XmlElement)documentoNode;

                            string nRec = Functions.LerTag(documentoElemento, ElementoEditavel.nRec.ToString(), "");
                            string versao = Functions.LerTag(documentoElemento, ElementoEditavel.versao.ToString(), "");
                            string ChaveNFe = documentoElemento.GetAttribute(ElementoFixo.ChaveNFe.ToString());
                            string NomeArquivo = Functions.LerTag(documentoElemento, ElementoFixo.ArqNFe.ToString(), "");
                            string NomeArquivoEmProcessamento = Empresas.Configuracoes[empresa].PastaXmlEnviado + "\\" + PastaEnviados.EmProcessamento.ToString() + "\\" + NomeArquivo;
                            string NomeArquivoAssinado = Empresas.Configuracoes[empresa].PastaXmlEnvio + "\\" + Propriedade.NomePastaXMLAssinado + "\\" + NomeArquivo;
                            string NomeArquivoAssinadoLote = Empresas.Configuracoes[empresa].PastaXmlEmLote + "\\" + Propriedade.NomePastaXMLAssinado + "\\" + NomeArquivo;
                            string mod = Functions.LerTag(documentoElemento, ElementoEditavel.mod.ToString(), "");
                            bool excluiNota = false;
                            if (File.Exists(NomeArquivoEmProcessamento))
                            {
                                int tMed = 3; //3 segundos
                                DateTime dPedRec = DateTime.Now.AddMinutes(-60);

                                tMed = Convert.ToInt32(Functions.LerTag(documentoElemento, ElementoEditavel.tMed.ToString(), tMed.ToString()));
                                dPedRec = Convert.ToDateTime(Functions.LerTag(documentoElemento, ElementoEditavel.dPedRec.ToString(), dPedRec.ToString("yyyy-MM-dd HH:mm:ss")));                                

                                //Se tiver mais de 2 dias no fluxo, vou excluir a nota dele.
                                //Não faz sentido uma nota ficar no fluxo todo este tempo, então vou fazer uma limpeza
                                //Wandrey 11/09/2009
                                if (DateTime.Now.Subtract(dPedRec).Days >= 2)
                                {
                                    excluiNota = true;
                                }
                                else
                                {
                                    if (nRec != string.Empty && !lstNumRec.Contains(nRec))
                                    {
                                        lstNumRec.Add(nRec);

                                        ReciboCons oReciboCons = new ReciboCons();
                                        oReciboCons.dPedRec = dPedRec;
                                        oReciboCons.nRec = nRec;
                                        oReciboCons.tMed = tMed;
                                        oReciboCons.versao = versao;
                                        oReciboCons.mod = mod;
                                        lstRecibo.Add(oReciboCons);
                                    }
                                }
                            }
                            else if (! File.Exists(NomeArquivoAssinado) && ! File.Exists(NomeArquivoAssinadoLote))
                                excluiNota = true;

                            if (excluiNota)
                            {
                                //Deletar o arquivo da pasta em processamento
                                Auxiliar oAux = new Auxiliar();
                                oAux.MoveArqErro(NomeArquivoEmProcessamento);

                                //Deletar a NFE do arquivo de controle de fluxo
                                ExcluirNfeFluxo(ChaveNFe);
                            }
                        }
                        break;
                    }
                }
                catch
                {
                    if (fsArquivo != null)
                    {
                        fsArquivo.Close();
                    }

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

                Thread.Sleep(1000);
            }

            return lstRecibo;
        }