/// <summary>
/// Inutiliza uma faixa de números
/// </summary>
/// <param name="cnpj"></param>
/// <param name="ano"></param>
/// <param name="modelo"></param>
/// <param name="serie"></param>
/// <param name="numeroInicial"></param>
/// <param name="numeroFinal"></param>
/// <param name="justificativa"></param>
/// <returns>Retorna um objeto da classe RetornoNfeInutilizacao com o retorno do serviço NfeInutilizacao</returns>
public RetornoNfeInutilizacao NfeInutilizacao(string cnpj, int ano, ModeloDocumento modelo, int serie, int numeroInicial, int numeroFinal, string justificativa)
{
var versaoServico = Conversao.VersaoServicoParaString(ServicoNFe.NfeInutilizacao, _cFgServico.VersaoNfeInutilizacao);
#region Cria o objeto wdsl para consulta
var ws = CriarServico(ServicoNFe.NfeInutilizacao);
ws.nfeCabecMsg = new nfeCabecMsg
{
cUF = _cFgServico.cUF,
versaoDados = versaoServico
};
#endregion
#region Cria o objeto inutNFe
var pedInutilizacao = new inutNFe
{
versao = versaoServico,
infInut = new infInutEnv
{
tpAmb = _cFgServico.tpAmb,
cUF = _cFgServico.cUF,
ano = ano,
CNPJ = cnpj,
mod = modelo,
serie = serie,
nNFIni = numeroInicial,
nNFFin = numeroFinal,
xJust = justificativa
}
};
var numId = string.Concat((int)pedInutilizacao.infInut.cUF, pedInutilizacao.infInut.ano,
pedInutilizacao.infInut.CNPJ, (int)pedInutilizacao.infInut.mod, pedInutilizacao.infInut.serie.ToString().PadLeft(3, '0'),
pedInutilizacao.infInut.nNFIni.ToString().PadLeft(9, '0'), pedInutilizacao.infInut.nNFFin.ToString().PadLeft(9, '0'));
pedInutilizacao.infInut.Id = "ID" + numId;
pedInutilizacao.Assina();
#endregion
#region Valida, Envia os dados e obtém a resposta
var xmlInutilizacao = pedInutilizacao.ObterXmlString();
Validador.Valida(ServicoNFe.NfeInutilizacao, _cFgServico.VersaoNfeInutilizacao, xmlInutilizacao);
var dadosInutilizacao = new XmlDocument();
dadosInutilizacao.LoadXml(xmlInutilizacao);
SalvarArquivoXml(numId + "-ped-inu.xml", xmlInutilizacao);
var retorno = ws.Execute(dadosInutilizacao);
var retornoXmlString = retorno.OuterXml;
var retInutNFe = new retInutNFe().CarregarDeXmlString(retornoXmlString);
SalvarArquivoXml(numId + "-inu.xml", retornoXmlString);
return(new RetornoNfeInutilizacao(pedInutilizacao.ObterXmlString(), retInutNFe.ObterXmlString(), retornoXmlString, retInutNFe));
#endregion
}
/// <summary>
/// Envia um evento genérico
/// </summary>
/// <param name="idlote"></param>
/// <param name="eventos"></param>
/// <param name="tipoRecepcaoEvento"></param>
/// <returns>Retorna um objeto da classe RetornoRecepcaoEvento com o retorno do serviço RecepcaoEvento</returns>
private RetornoRecepcaoEvento RecepcaoEvento(int idlote, List <evento> eventos, TipoRecepcaoEvento tipoRecepcaoEvento)
{
var versaoServico = Auxiliar.VersaoServicoParaString(ServicoNFe.RecepcaoEvento, _cFgServico.VersaoRecepcaoEvento);
#region Cria o objeto wdsl para consulta
var ws = CriarServico(ServicoNFe.RecepcaoEvento, tipoRecepcaoEvento);
ws.nfeCabecMsg = new nfeCabecMsg
{
cUF = _cFgServico.cUF,
versaoDados = versaoServico
};
#endregion
#region Cria o objeto envEvento
var pedEvento = new envEvento
{
versao = versaoServico,
idLote = idlote,
evento = eventos
};
foreach (var evento in eventos)
{
evento.infEvento.Id = "ID" + evento.infEvento.tpEvento + evento.infEvento.chNFe + evento.infEvento.nSeqEvento.ToString().PadLeft(2, '0');
evento.Assina();
}
#endregion
#region Valida, Envia os dados e obtém a resposta
var xmlEvento = pedEvento.ObterXmlString();
Validador.Valida(ServicoNFe.RecepcaoEvento, tipoRecepcaoEvento, _cFgServico.VersaoRecepcaoEvento, xmlEvento);
var dadosEvento = new XmlDocument();
dadosEvento.LoadXml(xmlEvento);
SalvarArquivoXml(idlote + "-ped-eve.xml", xmlEvento);
var retorno = ws.Execute(dadosEvento);
var retornoXmlString = retorno.OuterXml;
var retEnvEvento = new retEnvEvento().CarregarDeXmlString(retornoXmlString);
SalvarArquivoXml(idlote + "-eve.xml", retornoXmlString);
#region Obtém um procEventoNFe de cada evento e salva em arquivo
var listprocEventoNFe = new List <procEventoNFe>();
foreach (var evento in eventos)
{
var eve = evento;
var query = (from retevento in retEnvEvento.retEvento
where retevento.infEvento.chNFe == eve.infEvento.chNFe && retevento.infEvento.tpEvento == eve.infEvento.tpEvento
select retevento).SingleOrDefault();
var procevento = new procEventoNFe {
evento = eve, versao = eve.versao, retEvento = new List <retEvento> {
query
}
};
listprocEventoNFe.Add(procevento);
if (!_cFgServico.SalvarXmlServicos)
{
continue;
}
var proceventoXmlString = procevento.ObterXmlString();
SalvarArquivoXml(procevento.evento.infEvento.Id.Substring(2) + "-procEventoNFe.xml", proceventoXmlString);
}
#endregion
return(new RetornoRecepcaoEvento(pedEvento.ObterXmlString(), retEnvEvento.ObterXmlString(), retornoXmlString, retEnvEvento, listprocEventoNFe));
#endregion
}
public static void ValidaSchema(this MDFeEvCancMDFe evCancMDFe)
{
var xmlCancelamento = evCancMDFe.XmlString();
Validador.Valida(xmlCancelamento, "evCancMDFe_v1.00.xsd");
}
private static void ValidarSchemaEventoContainer(EventoContainer container, versao versao)
{
if (container.GetType() == typeof(evCancCTe))
{
var evCancCTe = (evCancCTe)container;
var xmlEventoCancelamento = evCancCTe.ObterXmlString();
switch (versao)
{
case versao.ve200:
Validador.Valida(xmlEventoCancelamento, "evCancCTe_v2.00.xsd");
break;
case versao.ve300:
Validador.Valida(xmlEventoCancelamento, "evCancCTe_v3.00.xsd");
break;
default:
throw new InvalidOperationException("Nos achamos um erro na hora de validar o schema, " +
"a versão está inválida, somente é permitido " +
"versão 2.00 é 3.00");
}
}
if (container.GetType() == typeof(evCCeCTe))
{
var evCCeCTe = (evCCeCTe)container;
var xmlEventoCCe = evCCeCTe.ObterXmlString();
switch (versao)
{
case versao.ve200:
Validador.Valida(xmlEventoCCe, "evCCeCTe_v2.00.xsd");
break;
case versao.ve300:
Validador.Valida(xmlEventoCCe, "evCCeCTe_v3.00.xsd");
break;
default:
throw new InvalidOperationException("Nos achamos um erro na hora de validar o schema, " +
"a versão está inválida, somente é permitido " +
"versão 2.00 é 3.00");
}
}
if (container.GetType() == typeof(evPrestDesacordo))
{
var evPrestDesacordo = (evPrestDesacordo)container;
var xmlEventoCCe = evPrestDesacordo.ObterXmlString();
switch (versao)
{
case versao.ve200:
Validador.Valida(xmlEventoCCe, "evPrestDesacordo_v2.00.xsd");
break;
case versao.ve300:
Validador.Valida(xmlEventoCCe, "evPrestDesacordo_v3.00.xsd");
break;
default:
throw new InvalidOperationException("Nos achamos um erro na hora de validar o schema, " +
"a versão está inválida, somente é permitido " +
"versão 2.00 é 3.00");
}
}
}
public void Test1()
{
Validador.Valida(ServicoNFe.NFeAutorizacao, VersaoServico.ve100, null, false, "C:\\works\\nfe-products-api\\schemas");
}
/// <summary>
/// Gera id, cdv, assina e faz alguns ajustes nos dados da classe CTe antes de utilizá-la
/// </summary>
/// <param name="cte"></param>
/// <returns>Retorna um objeto CTe devidamente tradado</returns>
public static void ValidaSchema(this CteEletronica cte)
{
if (cte == null)
{
throw new ArgumentNullException("cte");
}
var xmlValidacao = cte.ObterXmlString();
switch (cte.infCte.versao)
{
case versao.ve200:
Validador.Valida(xmlValidacao, "cte_v2.00.xsd");
break;
case versao.ve300:
Validador.Valida(xmlValidacao, "cte_v3.00.xsd");
break;
default:
throw new InvalidOperationException("Nos achamos um erro na hora de validar o schema, " +
"a versão está inválida, somente é permitido " +
"versão 2.00 é 3.00");
}
if (cte.infCte.ide.tpCTe != tpCTe.Anulacao && cte.infCte.ide.tpCTe != tpCTe.Complemento) // Ct-e do Tipo Anulação/Complemento não tem Informações do Modal
{
var xmlModal = FuncoesXml.ClasseParaXmlString(cte.infCte.infCTeNorm.infModal);
switch (cte.infCte.infCTeNorm.infModal.versaoModal)
{
case versaoModal.veM200:
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(aereo))
{
Validador.Valida(xmlModal, "cteModalAereo_v2.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(aquav))
{
Validador.Valida(xmlModal, "cteModalAquaviario_v2.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(duto))
{
Validador.Valida(xmlModal, "cteModalDutoviario_v2.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(ferrov))
{
Validador.Valida(xmlModal, "cteModalFerroviario_v2.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(rodo))
{
Validador.Valida(xmlModal, "cteModalRodoviario_v2.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(multimodal))
{
Validador.Valida(xmlModal, "cteMultimodal_v2.00.xsd");
}
break;
case versaoModal.veM300:
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(aereo))
{
Validador.Valida(xmlModal, "cteModalAereo_v3.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(aquav))
{
Validador.Valida(xmlModal, "cteModalAquaviario_v3.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(duto))
{
Validador.Valida(xmlModal, "cteModalDutoviario_v3.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(ferrov))
{
Validador.Valida(xmlModal, "cteModalFerroviario_v3.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(rodo))
{
Validador.Valida(xmlModal, "cteModalRodoviario_v3.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(multimodal))
{
Validador.Valida(xmlModal, "cteMultimodal_v3.00.xsd");
}
if (cte.infCte.infCTeNorm.infModal.ContainerModal.GetType() == typeof(rodoOS))
{
Validador.Valida(xmlModal, "cteModalRodoviarioOS_v.3.00.xsd");
}
break;
default:
throw new InvalidOperationException("Nos achamos um erro na hora de validar o schema, " +
"a versão está inválida, somente é permitido " +
"versão 2.00 é 3.00");
}
}
}
public static void ValidarSchema(this MDFeCosMDFeNaoEnc consMdFeNaoEnc)
{
var xmlValidacao = consMdFeNaoEnc.XmlString();
Validador.Valida(xmlValidacao, "consMDFeNaoEnc_v1.00.xsd");
}
public static void ValidaSchema(this MDFeEvIncCondutorMDFe evIncCondutorMDFe)
{
var xmlIncluirCondutor = evIncCondutorMDFe.XmlString();
Validador.Valida(xmlIncluirCondutor, "evIncCondutorMDFe_v1.00.xsd");
}
/// <summary>
/// Consulta a situação cadastral, com base na UF/Documento
/// <para>O documento pode ser: IE, CNPJ ou CPF</para>
/// </summary>
/// <param name="uf">Sigla da UF consultada, informar 'SU' para SUFRAMA</param>
/// <param name="tipoDocumento">Tipo de documento a ser consultado</param>
/// <param name="documento">Documento a ser consultado</param>
/// <returns>Retorna um objeto da classe RetornoNfeConsultaCadastro com o retorno do serviço NfeConsultaCadastro</returns>
public RetornoNfeConsultaCadastro NfeConsultaCadastro(string uf,
ConsultaCadastroTipoDocumento tipoDocumento, string documento)
{
var versaoServico = Conversao.VersaoServicoParaString(ServicoNFe.NfeConsultaCadastro, _cFgServico.VersaoNfeConsultaCadastro);
#region Cria o objeto wdsl para consulta
var ws = CriarServico(ServicoNFe.NfeConsultaCadastro);
ws.nfeCabecMsg = new nfeCabecMsg
{
cUF = _cFgServico.cUF,
versaoDados = versaoServico
};
#endregion
#region Cria o objeto ConsCad
var pedConsulta = new ConsCad
{
versao = versaoServico,
infCons = new infConsEnv {
UF = uf
}
};
switch (tipoDocumento)
{
case ConsultaCadastroTipoDocumento.Ie:
pedConsulta.infCons.IE = documento;
break;
case ConsultaCadastroTipoDocumento.Cnpj:
pedConsulta.infCons.CNPJ = documento;
break;
case ConsultaCadastroTipoDocumento.Cpf:
pedConsulta.infCons.CPF = documento;
break;
default:
throw new ArgumentOutOfRangeException();
}
#endregion
#region Valida, Envia os dados e obtém a resposta
var xmlConsulta = pedConsulta.ObterXmlString();
Validador.Valida(ServicoNFe.NfeConsultaCadastro, _cFgServico.VersaoNfeConsultaCadastro, xmlConsulta);
var dadosConsulta = new XmlDocument();
dadosConsulta.LoadXml(xmlConsulta);
SalvarArquivoXml(DateTime.Now.ToString("yyyyMMddHHmmss") + "-ped-cad.xml", xmlConsulta);
var retorno = ws.Execute(dadosConsulta);
var retornoXmlString = retorno.OuterXml;
var retConsulta = new retConsCad().CarregarDeXmlString(retornoXmlString);
SalvarArquivoXml(DateTime.Now.ToString("yyyyMMddHHmmss") + "-cad.xml", retornoXmlString);
return(new RetornoNfeConsultaCadastro(pedConsulta.ObterXmlString(), retConsulta.ObterXmlString(), retornoXmlString, retConsulta));
#endregion
}
public static void ValidaSchema(this MDFeConsReciMDFe consReciMDFe)
{
var xmlValidacao = consReciMDFe.XmlString();
Validador.Valida(xmlValidacao, "consReciMdfe_v1.00.xsd");
}
public static void ValidarSchema(this MDFeConsStatServMDFe consStatServMDFe)
{
var xmlValidacao = consStatServMDFe.XmlString();
Validador.Valida(xmlValidacao, "consStatServMDFe_v1.00.xsd");
}
/// <summary>
/// Envia uma ou mais NFe
/// </summary>
/// <param name="idLote">ID do Lote</param>
/// <param name="indSinc">Indicador de Sincronização</param>
/// <param name="nFes">Lista de NFes a serem enviadas</param>
/// <param name="compactarMensagem">Define se a mensagem será enviada para a SEFAZ compactada</param>
/// <returns>Retorna um objeto da classe RetornoNFeAutorizacao com com os dados do resultado da transmissão</returns>
public RetornoNFeAutorizacao NFeAutorizacao(int idLote, IndicadorSincronizacao indSinc, List <Classes.NFe> nFes, bool compactarMensagem = false)
{
var versaoServico = ServicoNFe.NFeAutorizacao.VersaoServicoParaString(_cFgServico.VersaoNFeAutorizacao);
#region Cria o objeto wdsl para consulta
var ws = CriarServicoAutorizacao(ServicoNFe.NFeAutorizacao);
ws.nfeCabecMsg = new nfeCabecMsg
{
cUF = _cFgServico.cUF,
versaoDados = versaoServico
};
#endregion
#region Cria o objeto enviNFe
var pedEnvio = new enviNFe3(versaoServico, idLote, indSinc, nFes);
#endregion
#region Valida, Envia os dados e obtém a resposta
var xmlEnvio = pedEnvio.ObterXmlString();
if (_cFgServico.cUF == Estado.PR) //Caso o lote seja enviado para o PR, colocar o namespace nos elementos <NFe> do lote, pois o serviço do PR o exige, conforme https://github.com/adeniltonbs/Zeus.Net.NFe.NFCe/issues/33
{
xmlEnvio = xmlEnvio.Replace("<NFe>", "<NFe xmlns=\"http://www.portalfiscal.inf.br/nfe\">");
}
Validador.Valida(ServicoNFe.NFeAutorizacao, _cFgServico.VersaoNFeAutorizacao, xmlEnvio);
var dadosEnvio = new XmlDocument();
dadosEnvio.LoadXml(xmlEnvio);
SalvarArquivoXml(idLote + "-env-lot.xml", xmlEnvio);
XmlNode retorno;
try
{
if (compactarMensagem)
{
var xmlCompactado = Convert.ToBase64String(Compressao.Zip(xmlEnvio));
retorno = ws.ExecuteZip(xmlCompactado);
}
else
{
retorno = ws.Execute(dadosEnvio);
}
}
catch (Exception ex)
{
throw new ExecutionException(ex.Message);
}
var retornoXmlString = retorno.OuterXml;
var retEnvio = new retEnviNFe().CarregarDeXmlString(retornoXmlString);
SalvarArquivoXml(idLote + "-rec.xml", retornoXmlString);
return(new RetornoNFeAutorizacao(pedEnvio.ObterXmlString(), retEnvio.ObterXmlString(), retornoXmlString, retEnvio));
#endregion
}
