public static MDFeRetConsMDFeNao LoadXmlString(string xml)
{
var retorno = FuncoesXml.XmlStringParaClasse <MDFeRetConsMDFeNao>(xml);
retorno.RetornoXmlString = xml;
return(retorno);
}
public static retCTeOS LoadXml(string xml)
{
var retorno = FuncoesXml.XmlStringParaClasse <retCTeOS>(xml);
retorno.RetornoXmlString = xml;
return(retorno);
}
private static DanfeFrEvento GeraClasseDanfeFrEvento(string xml, string xmlEvento)
{
var configuracaoDanfeNfe = _configuracoes.ConfiguracaoDanfeNfe;
var proc = new nfeProc().CarregarDeXmlString(xml);
if (proc.NFe.infNFe.ide.mod != ModeloDocumento.NFe)
{
throw new Exception("O XML informado não é um NFe!");
}
var procEvento = FuncoesXml.XmlStringParaClasse <procEventoNFe>(xmlEvento);
DanfeFrEvento danfe = new DanfeFrEvento(proc: proc, procEventoNFe: procEvento, configuracaoDanfeNfe: new ConfiguracaoDanfeNfe()
{
Logomarca = configuracaoDanfeNfe.Logomarca,
DuasLinhas = false,
DocumentoCancelado = false,
QuebrarLinhasObservacao = configuracaoDanfeNfe.QuebrarLinhasObservacao,
ExibirResumoCanhoto = configuracaoDanfeNfe.ExibirResumoCanhoto,
ResumoCanhoto = configuracaoDanfeNfe.ResumoCanhoto,
ChaveContingencia = configuracaoDanfeNfe.ChaveContingencia,
ExibeCampoFatura = configuracaoDanfeNfe.ExibeCampoFatura,
ImprimirISSQN = configuracaoDanfeNfe.ImprimirISSQN,
ImprimirDescPorc = configuracaoDanfeNfe.ImprimirDescPorc,
ImprimirTotalLiquido = configuracaoDanfeNfe.ImprimirTotalLiquido,
ImprimirUnidQtdeValor = configuracaoDanfeNfe.ImprimirUnidQtdeValor,
ExibirTotalTributos = configuracaoDanfeNfe.ExibirTotalTributos
},
desenvolvedor: "NOME DA SOFTWARE HOUSE");
return(danfe);
}
private static retConsStatServCte LoadXml(string xml)
{
var retorno = FuncoesXml.XmlStringParaClasse <retConsStatServCte>(xml);
retorno.RetornoXmlString = xml;
return(retorno);
}
public static MDFeRetEnviMDFe LoadXml(string xml)
{
var retorno = FuncoesXml.XmlStringParaClasse <MDFeRetEnviMDFe>(xml);
retorno.RetornoXmlString = xml;
return(retorno);
}
private static retInutCTe LoadXml(string xml)
{
var retorno = FuncoesXml.XmlStringParaClasse <retInutCTe>(xml);
retorno.RetornoXmlString = xml;
return(retorno);
}
/// <summary>
/// Obtém a assinatura de um objeto serializável
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="objeto"></param>
/// <param name="id"></param>
/// <param name="certificadoDigital">Informe o certificado digital</param>
/// <param name="manterDadosEmCache">Validador para manter o certificado em cache</param>
/// <returns>Retorna um objeto do tipo Classes.Assinatura.Signature, contendo a assinatura do objeto passado como parâmetro</returns>
public static Signature ObterAssinatura <T>(T objeto, string id, X509Certificate2 certificadoDigital, bool manterDadosEmCache = false, string signatureMethod = "http://www.w3.org/2000/09/xmldsig#rsa-sha1", string digestMethod = "http://www.w3.org/2000/09/xmldsig#sha1") where T : class
{
var objetoLocal = objeto;
if (id == null)
{
throw new Exception("Não é possível assinar um objeto evento sem sua respectiva Id!");
}
try
{
var documento = new XmlDocument {
PreserveWhitespace = true
};
documento.LoadXml(FuncoesXml.ClasseParaXmlString(objetoLocal));
var docXml = new SignedXml(documento)
{
SigningKey = certificadoDigital.PrivateKey
};
docXml.SignedInfo.SignatureMethod = signatureMethod;
var reference = new Reference {
Uri = "#" + id, DigestMethod = digestMethod
};
// adicionando EnvelopedSignatureTransform a referencia
var envelopedSigntature = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(envelopedSigntature);
var c14Transform = new XmlDsigC14NTransform();
reference.AddTransform(c14Transform);
docXml.AddReference(reference);
// carrega o certificado em KeyInfoX509Data para adicionar a KeyInfo
var keyInfo = new KeyInfo();
keyInfo.AddClause(new KeyInfoX509Data(certificadoDigital));
docXml.KeyInfo = keyInfo;
docXml.ComputeSignature();
//// recuperando a representação do XML assinado
var xmlDigitalSignature = docXml.GetXml();
var assinatura = FuncoesXml.XmlStringParaClasse <Signature>(xmlDigitalSignature.OuterXml);
return(assinatura);
}
finally
{
//Se não mantém os dados do certificado em cache e o certificado não foi passado por parâmetro(isto é, ele foi criado dentro deste método),
//então libera o certificado, chamando o método reset.
if (!manterDadosEmCache & certificadoDigital == null)
{
certificadoDigital.Reset();
}
}
}
/// <summary>
/// Obtém a asinatura de um objeto serializável
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="objeto"></param>
/// <param name="id"></param>
/// <returns>Retorna um objeto do tipo Classes.Assinatura.Signature, contendo a assinatura do objeto passado como parâmetro</returns>
public static Signature ObterAssinatura <T>(T objeto, string id) where T : class
{
var objetoLocal = objeto;
if (id == null)
{
throw new Exception("Não é possível assinar um objeto evento sem sua respectiva Id!");
}
var serialCertificado = ConfiguracaoServico.Instancia.SerialCertificado;
if (String.IsNullOrEmpty(serialCertificado))
{
throw new Exception("O nº de série do certificado não foi informado para a função ObterAssinatura!");
}
var certificado = CertificadoDigital.BuscaCertificado(serialCertificado);
var documento = new XmlDocument {
PreserveWhitespace = true
};
documento.LoadXml(FuncoesXml.ClasseParaXmlString(objetoLocal));
var docXml = new SignedXml(documento)
{
SigningKey = certificado.PrivateKey
};
var reference = new Reference {
Uri = "#" + id
};
// adicionando EnvelopedSignatureTransform a referencia
var envelopedSigntature = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(envelopedSigntature);
var c14Transform = new XmlDsigC14NTransform();
reference.AddTransform(c14Transform);
docXml.AddReference(reference);
// carrega o certificado em KeyInfoX509Data para adicionar a KeyInfo
var keyInfo = new KeyInfo();
keyInfo.AddClause(new KeyInfoX509Data(certificado));
docXml.KeyInfo = keyInfo;
docXml.ComputeSignature();
//// recuperando a representacao do XML assinado
var xmlDigitalSignature = docXml.GetXml();
var assinatura = FuncoesXml.XmlStringParaClasse <Signature>(xmlDigitalSignature.OuterXml);
return(assinatura);
}
public static SignatureZeus Assina <T>(T objeto, string id, X509Certificate2 certificado,
string signatureMethod = "http://www.w3.org/2000/09/xmldsig#rsa-sha1",
string digestMethod = "http://www.w3.org/2000/09/xmldsig#sha1",
bool cfgServicoRemoverAcentos = false) where T : class
{
var objetoLocal = objeto;
if (id == null)
{
throw new Exception("Não é possível assinar um objeto evento sem sua respectiva Id!");
}
var documento = new XmlDocument {
PreserveWhitespace = true
};
documento.LoadXml(cfgServicoRemoverAcentos
? FuncoesXml.ClasseParaXmlString(objetoLocal).RemoverAcentos()
: FuncoesXml.ClasseParaXmlString(objetoLocal));
var docXml = new SignedXml(documento)
{
SigningKey = certificado.PrivateKey
};
docXml.SignedInfo.SignatureMethod = signatureMethod;
var reference = new Reference {
Uri = "#" + id, DigestMethod = digestMethod
};
// adicionando EnvelopedSignatureTransform a referencia
var envelopedSigntature = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(envelopedSigntature);
var c14Transform = new XmlDsigC14NTransform();
reference.AddTransform(c14Transform);
docXml.AddReference(reference);
// carrega o certificado em KeyInfoX509Data para adicionar a KeyInfo
var keyInfo = new KeyInfo();
keyInfo.AddClause(new KeyInfoX509Data(certificado));
docXml.KeyInfo = keyInfo;
docXml.ComputeSignature();
//// recuperando a representacao do XML assinado
var xmlDigitalSignature = docXml.GetXml();
var assinatura = FuncoesXml.XmlStringParaClasse <Classes.Assinatura.Signature>(xmlDigitalSignature.OuterXml);
return(assinatura);
}
/// <summary>
/// Obtém a assinatura de um objeto serializável
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="objeto"></param>
/// <param name="id"></param>
/// <param name="certificadoDigital">Informe o certificado digital, se já possuir esse em cache, evitando novo acesso ao certificado</param>
/// <returns>Retorna um objeto do tipo Classes.Assinatura.Signature, contendo a assinatura do objeto passado como parâmetro</returns>
public static Signature ObterAssinatura <T>(T objeto, string id, X509Certificate2 certificadoDigital = null) where T : class
{
var objetoLocal = objeto;
if (id == null)
{
throw new Exception("Não é possível assinar um objeto evento sem sua respectiva Id!");
}
var certificado = certificadoDigital ?? CertificadoDigital.ObterCertificado();
try
{
var documento = new XmlDocument {
PreserveWhitespace = true
};
documento.LoadXml(FuncoesXml.ClasseParaXmlString(objetoLocal));
var docXml = new SignedXml(documento)
{
SigningKey = certificado.PrivateKey
};
var reference = new Reference {
Uri = "#" + id
};
// adicionando EnvelopedSignatureTransform a referencia
var envelopedSigntature = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(envelopedSigntature);
var c14Transform = new XmlDsigC14NTransform();
reference.AddTransform(c14Transform);
docXml.AddReference(reference);
// carrega o certificado em KeyInfoX509Data para adicionar a KeyInfo
var keyInfo = new KeyInfo();
keyInfo.AddClause(new KeyInfoX509Data(certificado));
docXml.KeyInfo = keyInfo;
docXml.ComputeSignature();
//// recuperando a representação do XML assinado
var xmlDigitalSignature = docXml.GetXml();
var assinatura = FuncoesXml.XmlStringParaClasse <Signature>(xmlDigitalSignature.OuterXml);
return(assinatura);
}
finally
{
if (!ConfiguracaoServico.Instancia.Certificado.ManterDadosEmCache)
{
certificado.Reset();
}
}
}
/// <summary>
/// Serviço destinado à distribuição de informações resumidas e documentos fiscais eletrônicos de interesse de um ator, seja este pessoa física ou jurídica.
/// </summary>
/// <param name="ufAutor">Código da UF do Autor</param>
/// <param name="documento">CNPJ/CPF do interessado no DF-e</param>
/// <param name="ultNSU">Último NSU recebido pelo Interessado</param>
/// <param name="nSU">Número Sequencial Único</param>
/// <param name="configuracaoServico"></param>
/// <returns>Retorna um objeto da classe CTeDistDFeInteresse com os documentos de interesse do CNPJ/CPF pesquisado</returns>
public RetornoCteDistDFeInt CTeDistDFeInteresse(string ufAutor, string documento, string ultNSU = "0", string nSU = "0", ConfiguracaoServico configuracaoServico = null)
{
var configServico = configuracaoServico ?? ConfiguracaoServico.Instancia;
distDFeInt pedDistDFeInt;
XmlDocument dadosConsulta;
var ws = InicializaCTeDistDFeInteresse(documento, ultNSU, nSU, out pedDistDFeInt, out dadosConsulta, configServico);
XmlNode retorno = ws.Execute(dadosConsulta);
var retornoXmlString = retorno.OuterXml;
var retConsulta = new retDistDFeInt().CarregarDeXmlString(retornoXmlString);
SalvarArquivoXml(DateTime.Now.ParaDataHoraString() + "-distDFeInt.xml", retornoXmlString, configServico);
#region Obtém um retDistDFeInt de cada evento e salva em arquivo
if (retConsulta.loteDistDFeInt != null && configServico.UnZip)
{
for (int i = 0; i < retConsulta.loteDistDFeInt.Length; i++)
{
string conteudo = Compressao.Unzip(retConsulta.loteDistDFeInt[i].XmlNfe);
string chCTe = string.Empty;
if (conteudo.StartsWith("<cteProc"))
{
var retConteudo = FuncoesXml.XmlStringParaClasse <CTe.Classes.cteProc>(conteudo);
chCTe = retConteudo.protCTe.infProt.chCTe;
}
else if (conteudo.StartsWith("<procEventoCTe"))
{
var procEventoNFeConteudo = FuncoesXml.XmlStringParaClasse <Classes.Servicos.DistribuicaoDFe.Schemas.procEventoCTe>(conteudo);
chCTe = procEventoNFeConteudo.eventoCTe.infEvento.chCTe;
}
string[] schema = retConsulta.loteDistDFeInt[i].schema.Split('_');
if (chCTe == string.Empty)
{
chCTe = DateTime.Now.ParaDataHoraString() + "_SEMCHAVE";
}
SalvarArquivoXml(chCTe + "-" + schema[0] + ".xml", conteudo, configServico);
}
}
#endregion
return(new RetornoCteDistDFeInt(pedDistDFeInt.ObterXmlString(), retConsulta.ObterXmlString(), retornoXmlString, retConsulta));
}
private Document TurnIntoDFeDocument(loteDistDFeInt[] loteDistDFeInt)
{
var docToReturn = new Document();
if (loteDistDFeInt != null)
{
for (int i = 0; i < loteDistDFeInt.Length; i++)
{
var documentNsu = loteDistDFeInt[i].NSU;
var xmlInBytes = loteDistDFeInt[i].XmlNfe;
string content = Compressao.Unzip(xmlInBytes);
if (content.StartsWith("<resNFe"))
{
var resNFeContent =
FuncoesXml.XmlStringParaClasse <NFe.Classes.Servicos.DistribuicaoDFe.Schemas.resNFe>(content);
docToReturn.AccessKey = resNFeContent.chNFe;
docToReturn.Amount = resNFeContent.vNF;
docToReturn.IssuerName = resNFeContent.xNome;
docToReturn.IssuerCnpj = resNFeContent.CNPJ.ToString();
}
if (CheckIfIsNfeProc(content))
{
var procNFeContent = new NFe.Classes.nfeProc().CarregarDeXmlString(content);
if (procNFeContent != null)
{
docToReturn.AccessKey = procNFeContent.protNFe.infProt.chNFe;
docToReturn.Amount = procNFeContent.NFe.infNFe.total.ICMSTot.vNF;
docToReturn.IssuerName = procNFeContent.NFe.infNFe.emit.xNome;
docToReturn.IssuerCnpj = procNFeContent.NFe.infNFe.emit.CNPJ;
}
}
}
}
return(docToReturn);
}
/// <summary>
/// Carrega um objeto do tipo retDistDFeInt a partir de uma string no formato XML
/// </summary>
/// <param name="retDistDFeInt">Objeto do tipo retDistDFeInt</param>
/// <param name="xmlString">String com uma estrutura XML</param>
/// <returns>Retorna um objeto retDistDFeInt com as informações da string XML</returns>
public static retDistDFeInt CarregarDeXmlString(this retDistDFeInt retDistDFeInt, string xmlString)
{
return(FuncoesXml.XmlStringParaClasse <retDistDFeInt>(xmlString));
}
internal static string ObterArquivoSchema(ServicoNFe servicoNFe, VersaoServico versaoServico, string stringXml, bool loteNfe = true)
{
switch (servicoNFe)
{
case ServicoNFe.NfeRecepcao:
return(loteNfe ? "enviNFe_v2.00.xsd" : "nfe_v2.00.xsd");
case ServicoNFe.RecepcaoEventoCancelmento:
var strEvento = FuncoesXml.ObterNodeDeStringXml(nameof(envEvento), stringXml);
var evento = FuncoesXml.XmlStringParaClasse <envEvento>(strEvento);
return(evento.evento.FirstOrDefault()?.infEvento?.tpEvento ==
NFeTipoEvento.TeNfeCancelamentoSubstituicao
? "envEventoCancSubst_v1.00.xsd"
: "envEventoCancNFe_v1.00.xsd");
case ServicoNFe.RecepcaoEventoCartaCorrecao:
return("envCCe_v1.00.xsd");
case ServicoNFe.RecepcaoEventoEpec:
return("envEPEC_v1.00.xsd");
case ServicoNFe.RecepcaoEventoManifestacaoDestinatario:
return("envConfRecebto_v1.00.xsd");
case ServicoNFe.NfeInutilizacao:
switch (versaoServico)
{
case VersaoServico.Versao200:
return("inutNFe_v2.00.xsd");
case VersaoServico.Versao310:
return("inutNFe_v3.10.xsd");
case VersaoServico.Versao400:
return("inutNFe_v4.00.xsd");
}
break;
case ServicoNFe.NfeConsultaProtocolo:
switch (versaoServico)
{
case VersaoServico.Versao200:
return("consSitNFe_v2.01.xsd");
case VersaoServico.Versao310:
return("consSitNFe_v3.10.xsd");
case VersaoServico.Versao400:
return("consSitNFe_v4.00.xsd");
}
break;
case ServicoNFe.NfeStatusServico:
switch (versaoServico)
{
case VersaoServico.Versao200:
return("consStatServ_v2.00.xsd");
case VersaoServico.Versao310:
return("consStatServ_v3.10.xsd");
case VersaoServico.Versao400:
return("consStatServ_v4.00.xsd");
}
break;
case ServicoNFe.NFeAutorizacao:
if (versaoServico != VersaoServico.Versao400)
{
return(loteNfe ? "enviNFe_v3.10.xsd" : "nfe_v3.10.xsd");
}
return(loteNfe ? "enviNFe_v4.00.xsd" : "nfe_v4.00.xsd");
case ServicoNFe.NfeConsultaCadastro:
return("consCad_v2.00.xsd");
case ServicoNFe.NfeDownloadNF:
return("downloadNFe_v1.00.xsd");
case ServicoNFe.NFeDistribuicaoDFe:
return("distDFeInt_v1.01.xsd"); // "distDFeInt_v1.00.xsd";
}
return(null);
}
/// <summary>
/// Coverte uma string XML no formato NFe para um objeto inutNFe
/// </summary>
/// <param name="inutNFe"></param>
/// <param name="xmlString"></param>
/// <returns>Retorna um objeto do tipo inutNFe</returns>
public static inutNFe CarregarDeXmlString(this inutNFe inutNFe, string xmlString)
{
return(FuncoesXml.XmlStringParaClasse <inutNFe>(xmlString));
}
/// <summary>
/// Coverte uma string XML no formato NFe para um objeto retConsReciNFe
/// </summary>
/// <param name="retConsReciNFe"></param>
/// <param name="xmlString"></param>
/// <returns>Retorna um objeto do tipo retConsReciNFe</returns>
public static retConsReciNFe CarregarDeXmlString(this retConsReciNFe retConsReciNFe, string xmlString)
{
return(FuncoesXml.XmlStringParaClasse <retConsReciNFe>(xmlString));
}
/// <summary>
/// Coverte uma string XML no formato CTe para um objeto CTe
/// </summary>
/// <param name="cte"></param>
/// <param name="xmlString"></param>
/// <returns>Retorna um objeto do tipo CTe</returns>
public static CteEletronica CarregarDeXmlString(this CteEletronica cte, string xmlString)
{
var s = FuncoesXml.ObterNodeDeStringXml(typeof(CteEletronica).Name, xmlString);
return(FuncoesXml.XmlStringParaClasse <CteEletronica>(s));
}
public static cteProc LoadXmlString(string xml)
{
return(FuncoesXml.XmlStringParaClasse <cteProc>(xml));
}
public static MDFeEnviMDFe LoadXmlString(string xml)
{
return(FuncoesXml.XmlStringParaClasse <MDFeEnviMDFe>(xml));
}
/// <summary>
/// Serviço destinado à distribuição de informações resumidas e documentos fiscais eletrônicos de interesse de um ator, seja este pessoa física ou jurídica.
/// </summary>
/// <param name="ufAutor">Código da UF do Autor</param>
/// <param name="documento">CNPJ/CPF do interessado no DF-e</param>
/// <param name="ultNSU">Último NSU recebido pelo Interessado</param>
/// <param name="nSU">Número Sequencial Único</param>
/// <returns>Retorna um objeto da classe CTeDistDFeInteresse com os documentos de interesse do CNPJ/CPF pesquisado</returns>
public RetornoCteDistDFeInt CTeDistDFeInteresse(string ufAutor, string documento, string ultNSU = "0", string nSU = "0")
{
var versaoServico = ConfiguracaoServico.Instancia.VersaoLayout;
#region Cria o objeto wdsl para consulta
var ws = WsdlFactory.CriaWsdlCTeDistDFeInteresse();
#endregion
#region Cria o objeto distCTeInt
var pedDistDFeInt = new distDFeInt
{
versao = "1.00",
tpAmb = ConfiguracaoServico.Instancia.tpAmb,
cUFAutor = ConfiguracaoServico.Instancia.cUF
};
if (documento.Length == 11)
{
pedDistDFeInt.CPF = documento;
}
if (documento.Length > 11)
{
pedDistDFeInt.CNPJ = documento;
}
pedDistDFeInt.distNSU = new distNSU {
ultNSU = ultNSU.PadLeft(15, '0')
};
if (!nSU.Equals("0"))
{
pedDistDFeInt.consNSU = new consNSU {
NSU = nSU.PadLeft(15, '0')
};
pedDistDFeInt.distNSU = null;
}
#endregion
#region Valida, Envia os dados e obtém a resposta
pedDistDFeInt.ValidaSchema();
var xmlConsulta = pedDistDFeInt.ObterXmlString();
var dadosConsulta = new XmlDocument();
dadosConsulta.LoadXml(xmlConsulta);
string path = DateTime.Now.ParaDataHoraString() + "-ped-DistDFeInt.xml";
SalvarArquivoXml(path, xmlConsulta);
XmlNode retorno = ws.Execute(dadosConsulta);
var retornoXmlString = retorno.OuterXml;
var retConsulta = new retDistDFeInt().CarregarDeXmlString(retornoXmlString);
SalvarArquivoXml(DateTime.Now.ParaDataHoraString() + "-distDFeInt.xml", retornoXmlString);
#region Obtém um retDistDFeInt de cada evento e salva em arquivo
if (retConsulta.loteDistDFeInt != null)
{
for (int i = 0; i < retConsulta.loteDistDFeInt.Length; i++)
{
string conteudo = Compressao.Unzip(retConsulta.loteDistDFeInt[i].XmlNfe);
string chCTe = string.Empty;
if (conteudo.StartsWith("<cteProc"))
{
var retConteudo = FuncoesXml.XmlStringParaClasse <CTe.Classes.cteProc>(conteudo);
chCTe = retConteudo.protCTe.infProt.chCTe;
}
else if (conteudo.StartsWith("<procEventoCTe"))
{
var procEventoNFeConteudo = FuncoesXml.XmlStringParaClasse <Classes.Servicos.DistribuicaoDFe.Schemas.procEventoCTe>(conteudo);
chCTe = procEventoNFeConteudo.eventoCTe.infEvento.chCTe;
}
string[] schema = retConsulta.loteDistDFeInt[i].schema.Split('_');
if (chCTe == string.Empty)
{
chCTe = DateTime.Now.ParaDataHoraString() + "_SEMCHAVE";
}
SalvarArquivoXml(chCTe + "-" + schema[0] + ".xml", conteudo);
}
}
#endregion
return(new RetornoCteDistDFeInt(pedDistDFeInt.ObterXmlString(), retConsulta.ObterXmlString(), retornoXmlString, retConsulta));
#endregion
}
/// <summary>
/// Coverte uma string XML no formato NFe para um objeto retConsCad
/// </summary>
/// <param name="retConsCad"></param>
/// <param name="xmlString"></param>
/// <returns>Retorna um objeto do tipo retConsCad</returns>
public static retConsCad CarregarDeXmlString(this retConsCad retConsCad, string xmlString)
{
return(FuncoesXml.XmlStringParaClasse <retConsCad>(xmlString));
}
/// <summary>
/// Coverte uma string XML no formato NFe para um objeto retEnviCte
/// </summary>
/// <param name="retEnviCte"></param>
/// <param name="xmlString"></param>
/// <returns>Retorna um objeto do tipo retEnviCte</returns>
public static retCTeOS CarregarDeXmlString(this retCTeOS retEnviCte, string xmlString)
{
return(FuncoesXml.XmlStringParaClasse <retCTeOS>(xmlString));
}
/// <summary>
/// Serviço destinado à distribuição de informações resumidas e documentos fiscais eletrônicos de interesse de um ator, seja este pessoa física ou jurídica.
/// </summary>
/// <param name="ufAutor">Código da UF do Autor</param>
/// <param name="documento">CNPJ/CPF do interessado no DF-e</param>
/// <param name="ultNSU">Último NSU recebido pelo Interessado</param>
/// <param name="nSU">Número Sequencial Único</param>
/// <returns>Retorna um objeto da classe RetornoNfeDistDFeInt com os documentos de interesse do CNPJ/CPF pesquisado</returns>
public RetornoNfeDistDFeInt NfeDistDFeInteresse(string ufAutor, string documento, string ultNSU, string nSU = "0")
{
var versaoServico = ServicoNFe.NFeDistribuicaoDFe.VersaoServicoParaString(_cFgServico.VersaoNFeDistribuicaoDFe);
#region Cria o objeto wdsl para consulta
var ws = CriarServico(ServicoNFe.NFeDistribuicaoDFe);
ws.nfeCabecMsg = new nfeCabecMsg
{
cUF = _cFgServico.cUF,
versaoDados = versaoServico
};
#endregion
#region Cria o objeto distDFeInt
var pedDistDFeInt = new distDFeInt
{
versao = versaoServico,
tpAmb = _cFgServico.tpAmb,
cUFAutor = _cFgServico.cUF,
distNSU = new distNSU {
ultNSU = ultNSU.PadLeft(15, '0')
}
};
if (documento.Length == 11)
{
pedDistDFeInt.CPF = documento;
}
if (documento.Length > 11)
{
pedDistDFeInt.CNPJ = documento;
}
if (!nSU.Equals("0"))
{
pedDistDFeInt.consNSU = new consNSU {
NSU = nSU.PadLeft(15, '0')
}
}
;
#endregion
#region Valida, Envia os dados e obtém a resposta
var xmlConsulta = pedDistDFeInt.ObterXmlString();
Validador.Valida(ServicoNFe.NFeDistribuicaoDFe, _cFgServico.VersaoNFeDistribuicaoDFe, xmlConsulta);
var dadosConsulta = new XmlDocument();
dadosConsulta.LoadXml(xmlConsulta);
SalvarArquivoXml(DateTime.Now.ToString("yyyyMMddHHmmss") + "-ped-DistDFeInt.xml", xmlConsulta);
var retorno = ws.Execute(dadosConsulta);
var retornoXmlString = retorno.OuterXml;
var retConsulta = new retDistDFeInt().CarregarDeXmlString(retornoXmlString);
SalvarArquivoXml(DateTime.Now.ToString("yyyyMMddHHmmss") + "-distDFeInt.xml", retornoXmlString);
#region Obtém um retDistDFeInt de cada evento e salva em arquivo
if (retConsulta.loteDistDFeInt != null)
{
for (int i = 0; i < retConsulta.loteDistDFeInt.Length; i++)
{
string conteudo = Compressao.Unzip(retConsulta.loteDistDFeInt[i].XmlNfe);
string chNFe = string.Empty;
if (conteudo.StartsWith("<retNFe"))
{
var retConteudo = FuncoesXml.XmlStringParaClasse <Classes.Servicos.DistribuicaoDFe.Schemas.resNFe>(conteudo);
chNFe = retConteudo.chNFe;
}
else if (conteudo.StartsWith("<procEventoNFe"))
{
var procEventoNFeConteudo = FuncoesXml.XmlStringParaClasse <Classes.Servicos.DistribuicaoDFe.Schemas.procEventoNFe>(conteudo);
chNFe = procEventoNFeConteudo.retEvento.infEvento.chNFe;
}
string[] schema = retConsulta.loteDistDFeInt[i].schema.Split('_');
SalvarArquivoXml(chNFe + "_" + schema[0] + ".xml", conteudo);
}
}
#endregion
return(new RetornoNfeDistDFeInt(pedDistDFeInt.ObterXmlString(), retConsulta.ObterXmlString(), retornoXmlString, retConsulta));
#endregion
}
/// <summary>
/// Carrega um objeto do tipo retEnvEvento a partir de uma string no formato XML
/// </summary>
/// <param name="retEnvEvento"></param>
/// <param name="xmlString"></param>
/// <returns>Retorna um objeto retEnvEvento com as informações da string XML</returns>
public static retEnvEvento CarregarDeXmlString(this retEnvEvento retEnvEvento, string xmlString)
{
return(FuncoesXml.XmlStringParaClasse <retEnvEvento>(xmlString));
}
/// <summary>
/// Carrega um arquivo XML para um objeto da classe CTe
/// </summary>
/// <param name="cte"></param>
/// <param name="arquivoXml">arquivo XML</param>
/// <returns>Retorna uma NFe carregada com os dados do XML</returns>
public static CteEletronica CarregarDeArquivoXml(this CteEletronica cte, string arquivoXml)
{
var s = FuncoesXml.ObterNodeDeArquivoXml(typeof(CteEletronica).Name, arquivoXml);
return(FuncoesXml.XmlStringParaClasse <CteEletronica>(s));
}
public static Models.evtInfoContri CarregarDeArquivoXml(this Models.evtInfoContri contri, string arquivoXml)
{
var s = FuncoesXml.ObterNodeDeArquivoXml(typeof(Models.evtInfoContri).Name, arquivoXml);
return(FuncoesXml.XmlStringParaClasse <Models.evtInfoContri>(s));
}
/// <summary>
/// Coverte uma string XML no formato NFe para um objeto retInutCTe
/// </summary>
/// <param name="retInutCTe"></param>
/// <param name="xmlString"></param>
/// <returns>Retorna um objeto do tipo retInutCTe</returns>
public static retInutCTe CarregarDeXmlString(this retInutCTe retInutCTe, string xmlString)
{
return(FuncoesXml.XmlStringParaClasse <retInutCTe>(xmlString));
}
/// <summary>
/// Carrega um arquivo XML para um objeto da classe NFe
/// </summary>
/// <param name="nfe"></param>
/// <param name="arquivoXml">arquivo XML</param>
/// <returns>Retorna uma NFe carregada com os dados do XML</returns>
public static Classes.NFe CarregarDeArquivoXml(this Classes.NFe nfe, string arquivoXml)
{
var s = FuncoesXml.ObterNodeDeArquivoXml(typeof(Classes.NFe).Name, arquivoXml);
return(FuncoesXml.XmlStringParaClasse <Classes.NFe>(s));
}
public static CTeOS LoadXmlString(string xml)
{
return(FuncoesXml.XmlStringParaClasse <CTeOS>(xml));
}
/// <summary>
/// Coverte uma string XML no formato NFe para um objeto NFe
/// </summary>
/// <param name="nfe"></param>
/// <param name="xmlString"></param>
/// <returns>Retorna um objeto do tipo NFe</returns>
public static Classes.NFe CarregarDeXmlString(this Classes.NFe nfe, string xmlString)
{
var s = FuncoesXml.ObterNodeDeStringXml(typeof(Classes.NFe).Name, xmlString);
return(FuncoesXml.XmlStringParaClasse <Classes.NFe>(s));
}
