/// <summary>
/// Assinar e Validar todos os arquivos XML de notas fiscais encontrados na pasta informada por parâmetro
/// </summary>
/// <param name="oNfe">Objeto do UniNFeClass a ser utilizado</param>
/// <param name="strPasta">Pasta onde está os XML´s</param>
private void AssinarValidarNFe(Object oNfe, string strPasta)
{
//Definir o tipo do serviço
Type tipoServico = oNfe.GetType();
//Monta a lista de XML´s encontrados na pasta
List <string> lstArquivos = this.ArquivosPasta(strPasta, "*" + ExtXml.Nfe);
//Assinar, Validar, Enviar ou somente processar os arquivos XML encontrados na pasta de envio
for (int i = 0; i < lstArquivos.Count; i++)
{
//Se o arquivo estiver em uso eu pulo ele para tentar mais tarde
if (Auxiliar.FileInUse(lstArquivos[i]))
{
continue;
}
string cError = "";
try
{
//Definir o arquivo XML
tipoServico.InvokeMember("vXmlNfeDadosMsg", System.Reflection.BindingFlags.SetProperty, null, oNfe, new object[] { lstArquivos[i] });
//Assinar e Validar o XML de nota fiscal eletrônica e coloca na pasta de Assinados
tipoServico.InvokeMember("AssinarValidarXMLNFe", System.Reflection.BindingFlags.InvokeMethod, null, oNfe, new Object[] { strPasta });
}
catch (IOException ex)
{
//System.Windows.Forms.MessageBox.Show(ex.Message);
cError = ex.Message;
}
catch (Exception ex)
{
//System.Windows.Forms.MessageBox.Show(ex.Message);
cError = ex.Message;
}
///
/// danasa 9-2009
///
if (!string.IsNullOrEmpty(cError))
{
Auxiliar oAux = new Auxiliar();
///
/// grava o arquivo de erro
///
oAux.GravarArqErroERP(Path.GetFileNameWithoutExtension(lstArquivos[i]) + ".err", cError);
///
/// move o arquivo para a pasta de erro
///
oAux.MoveArqErro(lstArquivos[i]);
}
}
}
/// <summary>
/// Executa as thread´s dos serviços da NFe
/// </summary>
/// <param name="empresa">Empresa que deve ser executado o serviço</param>
/// <param name="fullPath">Caminho e arquivo que deve ser tratado</param>
/// <remarks>
/// Autor: Wandrey Mundin Ferreira
/// Data: 22/04/2011
/// </remarks>
protected override void AbrirThread(int empresa, string fullPath)
{
while (true)
{
lock (Auxiliar.SmfThread)
{
Servicos tipoServico = Auxiliar.DefinirTipoServico(empresa, fullPath);
if (tipoServico == Servicos.Nulo)
{
break;
}
#region Executar a thread do serviço para processar o arquivo
if (ArquivoEmProcessamento.Exists(fullPath, StatusArquivoEmProcessamento.Aguardando) >= 0)
{
try
{
if (!File.Exists(fullPath))
{
break;
}
if (Auxiliar.FileInUse(fullPath))
{
continue;
}
if (File.ReadAllBytes(fullPath).Length <= 0)
{
continue;
}
ArquivoEmProcessamento.ChangeStatus(fullPath, StatusArquivoEmProcessamento.Processando);
ServicoUniNFe srv = new ServicoUniNFe();
Thread t = new Thread(new ParameterizedThreadStart(srv.ProcessaArquivo));
t.Name = empresa.ToString();
t.Start(new ParametroThread(tipoServico, fullPath));
break;
}
catch
{
ArquivoEmProcessamento.ChangeStatus(fullPath, StatusArquivoEmProcessamento.Aguardando);
}
}
#endregion
}
Thread.Sleep(2);
}
}
private void AssinarValidarXML()
{
int emp = new FindEmpresaThread(Thread.CurrentThread).Index;
///
/// danasa 21-9-2009
///
this.ConvTXT(Empresa.Configuracoes[emp].PastaValidar);
List <string> lstMascaras = new List <string>();
lstMascaras.Add(ExtXml.Nfe);
lstMascaras.Add(ExtXml.EnvLot);
lstMascaras.Add(ExtXml.PedRec);
lstMascaras.Add(ExtXml.PedSit);
lstMascaras.Add(ExtXml.PedSta);
lstMascaras.Add(ExtXml.PedCan);
lstMascaras.Add(ExtXml.PedInu);
lstMascaras.Add(ExtXml.PedSta);
lstMascaras.Add(ExtXml.ConsCad);
lstMascaras.Add(ExtXmlRet.ProcCancNFe);
lstMascaras.Add(ExtXmlRet.ProcInutNFe);
lstMascaras.Add(ExtXmlRet.ProcNFe);
lstMascaras.Add(ExtXml.ConsDPEC);
lstMascaras.Add(ExtXml.EnvDPEC);
Auxiliar oAux = new Auxiliar();
List <string> lstArquivos = new List <string>();
for (int i = 0; i < lstMascaras.Count; i++)
{
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaValidar, "*" + lstMascaras[i]);
for (int b = 0; b < lstArquivos.Count; b++)
{
if (Auxiliar.FileInUse(lstArquivos[b]))
{
continue;
}
oAux.ValidarAssinarXML(lstArquivos[b]);
}
lstArquivos.Clear();
}
Thread.Sleep(2000);
}
/// <summary>
/// Converter arquivos de NFe no formato TXT para XML
/// </summary>
/// <by>Wandrey Mundin Ferreira</by>
/// <date>03/069/2009</date>
protected void ConvTXT(string vPasta)
{
int emp = new FindEmpresaThread(Thread.CurrentThread).Index;
Auxiliar oAux = new Auxiliar();
List <string> lstArquivos = this.ArquivosPasta(vPasta /*ConfiguracaoApp.vPastaXMLEnvio*/, "*-nfe.txt");
for (int i = 0; i < lstArquivos.Count; i++)
{
if (Auxiliar.FileInUse(lstArquivos[i]))
{
continue;
}
UnitxtTOxmlClass oUniTxtToXml = new UnitxtTOxmlClass();
string ccMessage = string.Empty;
string ccExtension = "-nfe.err";
try
{
///
/// exclui o arquivo de erro
///
oAux.DeletarArquivo(Empresa.Configuracoes[emp].PastaRetorno + "\\" + Path.GetFileName(oAux.ExtrairNomeArq(lstArquivos[i], "-nfe.txt") + ccExtension));
oAux.DeletarArquivo(Empresa.Configuracoes[emp].PastaRetorno + "\\" + Path.GetFileName(oAux.ExtrairNomeArq(lstArquivos[i], "-nfe.txt") + "-nfe-ret.xml"));
oAux.DeletarArquivo(Empresa.Configuracoes[emp].PastaErro + "\\" + Path.GetFileName(lstArquivos[i]));
///
/// exclui o arquivo TXT original
///
oAux.DeletarArquivo(Empresa.Configuracoes[emp].PastaRetorno + "\\" + Path.GetFileNameWithoutExtension(lstArquivos[i]) + "-orig.txt");
///
/// processa a conversão
///
oUniTxtToXml.Converter(lstArquivos[i], vPasta /*ConfiguracaoApp.vPastaXMLEnvio*/);
//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(lstArquivos[i], ".txt");
}
else
{
///
/// salva o arquivo texto original
///
FileInfo otxtArquivo = new FileInfo(lstArquivos[i]);
if (vPasta.Equals(Empresa.Configuracoes[emp].PastaEnvio))
{
string vvNomeArquivoDestino = Empresa.Configuracoes[emp].PastaRetorno + "\\" + Path.GetFileNameWithoutExtension(lstArquivos[i]) + "-orig.txt";
otxtArquivo.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 (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
///
FileInfo oArquivo = new FileInfo(vPasta /*ConfiguracaoApp.vPastaXMLEnvio*/ + "\\convertidos\\" + txtClass.XMLFileName);
string vNomeArquivoDestino = vPasta /*ConfiguracaoApp.vPastaXMLEnvio*/ + "\\" + txtClass.XMLFileName;
///
/// excluo o XML se já existe
///
oAux.DeletarArquivo(vNomeArquivoDestino);
///
/// move o arquivo da pasta "Envio\Convertidos" para a pasta "Envio"
/// ou
/// move o arquivo da pasta "Validar\Convertidos" para a pasta "Validar"
///
oArquivo.MoveTo(vNomeArquivoDestino);
}
}
}
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(lstArquivos[i], ".txt");
///
/// exclui todos os XML gerados na pasta Enviados\convertidos
///
foreach (txtTOxmlClassRetorno txtClass in oUniTxtToXml.cRetorno)
{
oAux.DeletarArquivo(vPasta /*ConfiguracaoApp.vPastaXMLEnvio*/ + "\\convertidos\\" + txtClass.XMLFileName);
}
///
/// danasa 8-2009
///
/// Gravar o retorno para o ERP em formato TXT com o erro ocorrido
///
oAux.GravarArqErroERP(oAux.ExtrairNomeArq(lstArquivos[i], "-nfe.txt") + ccExtension, ccMessage);
}
}
}
/// <summary>
/// Monta o um lote com várias NFe´s
/// </summary>
/// <param name="oNfe">Objeto referente a instância da classe absServicoNFe</param>
/// <by>Wandrey Mundin Ferreira</by>
/// <date>28/04/2009</date>
private void MontarLoteVariasNfe(Object oNfe)
{
int emp = new FindEmpresaThread(Thread.CurrentThread).Index;
List <string> lstArqMontarLote = new List <string>();
//Aguardar a assinatura de todos os arquivos da pasta de lotes
lstArqMontarLote = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvioEmLote, "*" + ExtXml.Nfe);
if (lstArqMontarLote.Count > 0)
{
return;
}
//Verificar se existe o arquivo que solicita a montagem do lote
lstArqMontarLote = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvioEmLote, "*" + ExtXml.MontarLote);
for (int b = 0; b < lstArqMontarLote.Count; b++)
{
string NomeArquivo = lstArqMontarLote[b];
//O arquivo existe mas pode estar em uso
if (Auxiliar.FileInUse(NomeArquivo) == true)
{
return;
}
Auxiliar oAux = new Auxiliar();
List <string> lstNfe = new List <string>();
FileStream fsArquivo = null;
FluxoNfe oFluxoNfe = new FluxoNfe();
string MensagemErro = string.Empty;
bool lTeveErro = false;
try
{
XmlDocument doc = new XmlDocument(); //Criar instância do XmlDocument Class
fsArquivo = new FileStream(NomeArquivo, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); //Abrir um arquivo XML usando FileStream
doc.Load(fsArquivo); //Carregar o arquivo aberto no XmlDocument
XmlNodeList documentoList = doc.GetElementsByTagName("MontarLoteNFe"); //Pesquisar o elemento Documento no arquivo XML
foreach (XmlNode documentoNode in documentoList)
{
XmlElement documentoElemento = (XmlElement)documentoNode;
int QtdeArquivo = documentoElemento.GetElementsByTagName("ArquivoNFe").Count;
for (int d = 0; d < QtdeArquivo; d++)
{
string ArquivoNFe = Empresa.Configuracoes[emp].PastaEnvioEmLote + InfoApp.NomePastaXMLAssinado + "\\" + documentoElemento.GetElementsByTagName("ArquivoNFe")[d].InnerText;
if (File.Exists(ArquivoNFe))
{
try
{
LerXML.DadosNFeClass oDadosNfe = this.LerXMLNFe(ArquivoNFe);
if (!oFluxoNfe.NFeComLote(oDadosNfe.chavenfe))
{
lstNfe.Add(ArquivoNFe);
}
else
{
MensagemErro += "Arquivo: " + ArquivoNFe + " já está no fluxo de envio e não será incluido em novo lote.\r\n";
lTeveErro = true;
FileInfo oArq = new FileInfo(ArquivoNFe);
oArq.Delete();
}
}
catch (IOException ex)
{
MensagemErro += ex.Message + "\r\n";
lTeveErro = true;
}
catch (Exception ex)
{
MensagemErro += ex.Message + "\r\n";
lTeveErro = true;
}
}
else
{
lTeveErro = true;
MensagemErro += "Arquivo: " + ArquivoNFe + " não existe e não será incluido no lote!\r\n";
}
}
}
fsArquivo.Close(); //Fecha o arquivo XML
//Definir o tipo do serviço
Type tipoServico = oNfe.GetType();
try
{
//Gerar lote
tipoServico.InvokeMember("LoteNfe", System.Reflection.BindingFlags.InvokeMethod, null, oNfe, new object[] { lstNfe });
}
catch (IOException ex)
{
MensagemErro += ex.Message + "\r\n";
lTeveErro = true;
}
catch (Exception ex)
{
MensagemErro += ex.Message + "\r\n";
lTeveErro = true;
}
}
catch (Exception ex)
{
if (fsArquivo != null)
{
fsArquivo.Close();
}
lTeveErro = true;
MensagemErro += ex.Message + "\r\n";
}
//Deletar o arquivo de solicitão de montagem do lote de NFe
try
{
FileInfo oArquivo = new FileInfo(NomeArquivo);
oArquivo.Delete();
}
catch (IOException ex)
{
lTeveErro = true;
MensagemErro += ex.Message + "\r\n";
}
catch (Exception ex)
{
lTeveErro = true;
MensagemErro += ex.Message + "\r\n";
}
if (lTeveErro)
{
try
{
oAux.GravarArqErroServico(NomeArquivo, ExtXml.MontarLote, "-montar-lote.err", MensagemErro);
}
catch
{
//Se deu algum erro na hora de gravar o arquivo de erro de retorno para o ERP, infelizmente não poderemos fazer nada
//pois deve estar ocorrendo alguma falha de rede, hd, permissão de acesso a pasta ou arquivos, etc. Wandrey 22/03/2010
}
}
}
}
/// <summary>
/// Processa/envia os XML´s gravados na pasta de envio
/// </summary>
/// <param name="oNfe">Objeto referente a UniNfeClass</param>
/// <param name="strPasta">Pasta de envio</param>
/// <param name="strMascara">Mascara dos arquivos a serem pesquisados e processados</param>
/// <param name="strAtividade">Atividade a ser executada com o(s) XML(s) encontrados</param>
/// <by>Wandrey Mundin Ferreira</by>
/// <date>03/04/2009</date>
protected void ProcessaXML(Object oNfe, Servicos srvServico)
{
string strPasta = string.Empty;
List <string> lstArquivos = new List <string>();
lstArquivos.Clear();
string strMascaraArq = string.Empty;
string strMetodo = string.Empty;
int emp = new FindEmpresaThread(Thread.CurrentThread).Index;
switch (srvServico)
{
case Servicos.EmProcessamento:
EmProcessamento();
break;
case Servicos.CancelarNFe:
strMetodo = "Cancelamento";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.PedCan);
lstArquivos.AddRange(this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.PedCan_TXT));
goto default;
case Servicos.InutilizarNumerosNFe:
strMetodo = "Inutilizacao";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.PedInu);
lstArquivos.AddRange(this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.PedInu_TXT));
goto default;
case Servicos.PedidoConsultaSituacaoNFe:
strMetodo = "Consulta";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.PedSit);
lstArquivos.AddRange(this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.PedSit_TXT));
goto default;
case Servicos.PedidoConsultaStatusServicoNFe:
strMetodo = "StatusServico";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.PedSta);
lstArquivos.AddRange(this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.PedSta_TXT));
goto default;
case Servicos.PedidoSituacaoLoteNFe:
strMetodo = "RetRecepcao";
this.GerarXMLPedRec(oNfe);
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.PedRec); //Tem que ficar depois de ter gerado os XML de consulta do recibo ou dá falha. Wandrey 22/05/2009
goto default;
case Servicos.ConsultaCadastroContribuinte:
strMetodo = "ConsultaCadastro";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.ConsCad);
lstArquivos.AddRange(this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.ConsCad_TXT));
goto default;
case Servicos.ConsultaInformacoesUniNFe:
strMetodo = "GravarXMLDadosCertificado";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.ConsInf);
lstArquivos.AddRange(this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.ConsInf_TXT));
goto default;
case Servicos.AlterarConfiguracoesUniNFe:
strMetodo = "ReconfigurarUniNfe";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.AltCon);
lstArquivos.AddRange(this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.AltCon_TXT));
goto default;
case Servicos.EnviarDPEC:
strMetodo = "RecepcaoDPEC";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.EnvDPEC);
lstArquivos.AddRange(this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.EnvDPEC_TXT));
goto default;
case Servicos.ConsultarDPEC:
strMetodo = "ConsultaDPEC";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.ConsDPEC);
lstArquivos.AddRange(this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.ConsDPEC_TXT));
goto default;
case Servicos.AssinarNFePastaEnvio:
this.AssinarValidarNFe(oNfe, Empresa.Configuracoes[emp].PastaEnvio);
break;
case Servicos.AssinarNFePastaEnvioEmLote:
if (Empresa.Configuracoes[emp].PastaEnvioEmLote != string.Empty)
{
this.AssinarValidarNFe(oNfe, Empresa.Configuracoes[emp].PastaEnvioEmLote);
}
break;
case Servicos.MontarLoteUmaNFe:
this.MontarLoteUmaNfe(oNfe);
break;
case Servicos.MontarLoteVariasNFe:
if (Empresa.Configuracoes[emp].PastaEnvioEmLote != string.Empty)
{
this.MontarLoteVariasNfe(oNfe);
}
break;
case Servicos.EnviarLoteNfe:
strMetodo = "Recepcao";
lstArquivos = this.ArquivosPasta(Empresa.Configuracoes[emp].PastaEnvio, "*" + ExtXml.EnvLot);
goto default;
case Servicos.ValidarAssinar:
this.AssinarValidarXML(); //Somente validar e assinar os diversos XML´s da NFe
break;
case Servicos.ConverterTXTparaXML:
this.ConvTXT(Empresa.Configuracoes[emp].PastaEnvio);
break;
case Servicos.GerarChaveNFe:
this.GerarChaveNFe();
break;
case Servicos.LimpezaTemporario:
ExecutaLimpeza();
break;
default: //Assinar, validar, enviar ou somente processar os arquivos XML encontrados na pasta de envio
for (int i = 0; i < lstArquivos.Count; i++)
{
//Se o arquivo estiver ainda em uso eu pulo ele para tentar mais tarde
if (Auxiliar.FileInUse(lstArquivos[i]))
{
continue;
}
try
{
//Processa ou envia o XML
this.EnviarArquivo(lstArquivos[i], oNfe, strMetodo);
}
catch
{
//Não pode ser tratado nenhum erro aqui, visto que já estão sendo tratados e devidamente retornados
//para o ERP no ponto da execução dos serviços. Foi muito bem testado e analisado. Wandrey 09/03/2010
}
}
break;
}
}
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);
}
}
/// <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);
}
/// <summary>
/// Cria o arquivo XML para o controle do fluxo
/// </summary>
/// <param name="forcar">Força criar o arquivo mesmo que já exista</param>
/// <by>Wandrey Mundin Ferreira</by>
/// <date>17/04/2009</date>
public void CriarXml(bool VerificaEstruturaXml)
{
XmlWriter xtw = null; // criar instância para xmltextwriter.
try
{
#region Testar para ver se o XML não tá danificado, ou seja, sem as tag´s iniciais, se tiver força recriar ele
bool ForcarCriar = false;
if (VerificaEstruturaXml)
{
XmlDocument doc = null;
FileStream fsArquivo = null;
try
{
fsArquivo = new FileStream(NomeXmlControleFluxo, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); //Abrir um arquivo XML usando FileStream
if (File.Exists(NomeXmlControleFluxo))
{
doc = new XmlDocument();
doc.Load(NomeXmlControleFluxo);
}
}
catch (Exception ex)
{
if (doc != null)
{
if (doc.DocumentElement == null)
{
ForcarCriar = true;
}
}
}
finally
{
if (fsArquivo != null)
{
fsArquivo.Close();
}
}
}
#endregion
if (!File.Exists(NomeXmlControleFluxo) || ForcarCriar)
{
///
/// danasa 20-9-2010
///
bool goCriaArquivoDeFluxo = true;
if (File.Exists(NomeXmlControleFluxo))
{
if (Auxiliar.FileInUse(NomeXmlControleFluxo))
{
///
/// O metodo "BuscarXML" acessa o metodo para criar o xml de fluxo, só que como ele é acessado várias vezes
/// e como o arquivo está sendo criado, é exibida várias mensagens de erro de acesso ao arquivo de fluxo
goCriaArquivoDeFluxo = false;
}
}
if (goCriaArquivoDeFluxo)
{
XmlWriterSettings oSettings = new XmlWriterSettings();
UTF8Encoding c = new UTF8Encoding(false);
oSettings.Encoding = c;
oSettings.Indent = true;
oSettings.IndentChars = "";
oSettings.NewLineOnAttributes = false;
oSettings.OmitXmlDeclaration = false;
xtw = XmlWriter.Create(NomeXmlControleFluxo, oSettings); //atribuir arquivo, caminho e codificação
xtw.WriteStartDocument(); //comaçar a escrever o documento
xtw.WriteStartElement(ElementoFixo.DocumentosNFe.ToString()); //Criar elemento raiz
xtw.WriteEndElement(); //encerrar tag DocumentosNFe
xtw.Flush();
}
}
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (xtw != null)
{
if (xtw.WriteState != WriteState.Closed)
{
xtw.Close(); //Fechar o arquivo e salvar
}
}
}
}
