public MDFeRetEnviMDFe MDFeRecepcao(long lote, MDFeEletronico mdfe)
{
var enviMDFe = ClassesFactory.CriaEnviMDFe(lote, mdfe);
switch (MDFeConfiguracao.VersaoWebService.VersaoLayout)
{
case VersaoServico.Versao100:
mdfe.InfMDFe.InfModal.VersaoModal = MDFeVersaoModal.Versao100;
mdfe.InfMDFe.Ide.ProxyDhIniViagem = mdfe.InfMDFe.Ide.DhIniViagem.ParaDataHoraStringSemUtc();
break;
case VersaoServico.Versao300:
mdfe.InfMDFe.InfModal.VersaoModal = MDFeVersaoModal.Versao300;
mdfe.InfMDFe.Ide.ProxyDhIniViagem = mdfe.InfMDFe.Ide.DhIniViagem.ParaDataHoraStringUtc();
break;
}
enviMDFe.MDFe.Assina(GerouChave, this);
enviMDFe.Valida();
enviMDFe.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlMDFeRecepcao();
OnAntesDeEnviar(enviMDFe);
var retornoXml = webService.mdfeRecepcaoLote(enviMDFe.CriaXmlRequestWs());
var retorno = MDFeRetEnviMDFe.LoadXml(retornoXml.OuterXml, enviMDFe);
retorno.SalvarXmlEmDisco();
return(retorno);
}
private CTeDistDFeInteresse InicializaCTeDistDFeInteresse(string documento, string ultNSU, string nSU,
out distDFeInt pedDistDFeInt, out XmlDocument dadosConsulta, ConfiguracaoServico configuracaoServico)
{
var versaoServico = configuracaoServico.VersaoLayout;
#region Cria o objeto wdsl para consulta
var ws = WsdlFactory.CriaWsdlCTeDistDFeInteresse(configuracaoServico);
#endregion
#region Cria o objeto distCTeInt
pedDistDFeInt = new distDFeInt
{
versao = "1.00",
tpAmb = configuracaoServico.tpAmb,
cUFAutor = configuracaoServico.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
pedDistDFeInt.ValidaSchema(configuracaoServico);
var xmlConsulta = pedDistDFeInt.ObterXmlString();
dadosConsulta = new XmlDocument();
dadosConsulta.LoadXml(xmlConsulta);
string path = DateTime.Now.ParaDataHoraString() + "-ped-DistDFeInt.xml";
SalvarArquivoXml(path, xmlConsulta, configuracaoServico);
return(ws);
}
public retConsReciCTe Consultar()
{
var consReciCTe = ClassesFactory.CriaConsReciCTe(_recibo);
consReciCTe.ValidarSchema();
consReciCTe.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlCteRetRecepcao();
var retornoXml = webService.cteRetRecepcao(consReciCTe.CriaRequestWs());
var retorno = retConsReciCTe.LoadXml(retornoXml.OuterXml, consReciCTe);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public MDFeRetConsSitMDFe MDFeConsultaProtocolo(string chave)
{
var consSitMdfe = ClassesFactory.CriarConsSitMDFe(chave);
consSitMdfe.ValidarSchema();
consSitMdfe.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlMDFeConsulta();
var retornoXml = webService.mdfeConsultaMDF(consSitMdfe.CriaRequestWs());
var retorno = MDFeRetConsSitMDFe.LoadXml(retornoXml.OuterXml, consSitMdfe);
retorno.SalvarXmlEmDisco(chave);
return(retorno);
}
public retConsStatServCte ConsultaStatus(ConfiguracaoServico configuracaoServico = null)
{
var consStatServCte = ClassesFactory.CriaConsStatServCte(configuracaoServico);
consStatServCte.ValidarSchema(configuracaoServico);
consStatServCte.SalvarXmlEmDisco(configuracaoServico);
var webService = WsdlFactory.CriaWsdlCteStatusServico(configuracaoServico);
var retornoXml = webService.cteStatusServicoCT(consStatServCte.CriaRequestWs());
var retorno = retConsStatServCte.LoadXml(retornoXml.OuterXml, consStatServCte);
retorno.SalvarXmlEmDisco(configuracaoServico);
return(retorno);
}
public retConsSitCTe ConsultaProtocolo(string chave, ConfiguracaoServico configuracaoServico = null)
{
var consSitCTe = ClassesFactory.CriarconsSitCTe(chave, configuracaoServico);
consSitCTe.ValidarSchema(configuracaoServico);
consSitCTe.SalvarXmlEmDisco(configuracaoServico);
var webService = WsdlFactory.CriaWsdlConsultaProtocolo(configuracaoServico);
var retornoXml = webService.cteConsultaCT(consSitCTe.CriaRequestWs());
var retorno = retConsSitCTe.LoadXml(retornoXml.OuterXml, consSitCTe);
retorno.SalvarXmlEmDisco(chave, configuracaoServico);
return(retorno);
}
public MDFeRetConsMDFeNao MDFeConsultaNaoEncerrados(string cnpj)
{
var consMDFeNaoEnc = ClassesFactory.CriarConsMDFeNaoEnc(cnpj);
consMDFeNaoEnc.ValidarSchema();
consMDFeNaoEnc.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlMDFeConsNaoEnc();
var retornoXml = webService.mdfeConsNaoEnc(consMDFeNaoEnc.CriaRequestWs());
var retorno = MDFeRetConsMDFeNao.LoadXmlString(retornoXml.OuterXml, consMDFeNaoEnc);
retorno.SalvarXmlEmDisco(cnpj);
return(retorno);
}
public async Task <retEnviCte> CTeRecepcaoAsync(int lote, List <CTeEletronico> cteEletronicosList, ConfiguracaoServico configuracaoServico = null)
{
var enviCte = PreparaEnvioCTe(lote, cteEletronicosList, configuracaoServico);
var webService = WsdlFactory.CriaWsdlCteRecepcao(configuracaoServico);
OnAntesDeEnviar(enviCte);
var retornoXml = await webService.cteRecepcaoLoteAsync(enviCte.CriaRequestWs(configuracaoServico));
var retorno = retEnviCte.LoadXml(retornoXml.OuterXml, enviCte);
retorno.SalvarXmlEmDisco(configuracaoServico);
return(retorno);
}
public async Task <retConsReciCTe> ConsultarAsync(ConfiguracaoServico configuracaoServico = null)
{
var consReciCTe = ClassesFactory.CriaConsReciCTe(_recibo, configuracaoServico);
consReciCTe.ValidarSchema(configuracaoServico);
consReciCTe.SalvarXmlEmDisco(configuracaoServico);
var webService = WsdlFactory.CriaWsdlCteRetRecepcao(configuracaoServico);
var retornoXml = await webService.cteRetRecepcaoAsync(consReciCTe.CriaRequestWs());
var retorno = retConsReciCTe.LoadXml(retornoXml.OuterXml, consReciCTe);
retorno.SalvarXmlEmDisco(configuracaoServico);
return(retorno);
}
public async Task <retConsStatServCte> ConsultaStatusAsync()
{
var consStatServCte = ClassesFactory.CriaConsStatServCte();
consStatServCte.ValidarSchema();
consStatServCte.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlCteStatusServico();
var retornoXml = await webService.cteStatusServicoCTAsync(consStatServCte.CriaRequestWs());
var retorno = retConsStatServCte.LoadXml(retornoXml.OuterXml, consStatServCte);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public MDFeRetConsStatServ MDFeStatusServico()
{
var consStatServMDFe = ClassesFactory.CriaConsStatServMDFe();
consStatServMDFe.ValidarSchema();
consStatServMDFe.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlMDFeStatusServico();
var retornoXml = webService.mdfeStatusServicoMDF(consStatServMDFe.CriaRequestWs());
var retorno = MDFeRetConsStatServ.LoadXml(retornoXml.OuterXml, consStatServMDFe);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public MDFeRetConsReciMDFe MDFeRetRecepcao(string numeroRecibo)
{
var consReciMdfe = ClassesFactory.CriaConsReciMDFe(numeroRecibo);
consReciMdfe.ValidaSchema();
consReciMdfe.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlMDFeRetRecepcao();
var retornoXml = webService.mdfeRetRecepcao(consReciMdfe.CriaRequestWs());
var retorno = MDFeRetConsReciMDFe.LoadXml(retornoXml.OuterXml, consReciMdfe);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public retEnviCte CTeRecepcao(int lote, List <CTeEletronico> cteEletronicosList)
{
var enviCte = PreparaEnvioCTe(lote, cteEletronicosList);
var webService = WsdlFactory.CriaWsdlCteRecepcao();
OnAntesDeEnviar(enviCte);
var retornoXml = webService.cteRecepcaoLote(enviCte.CriaRequestWs());
var retorno = retEnviCte.LoadXml(retornoXml.OuterXml, enviCte);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public async Task <retConsSitCTe> ConsultaProtocolo(string chave)
{
var consSitCTe = ClassesFactory.CriarconsSitCTe(chave);
consSitCTe.ValidarSchema();
consSitCTe.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlConsultaProtocolo();
var retornoXml = await webService.cteConsultaCT(consSitCTe.CriaRequestWs());
var retorno = retConsSitCTe.LoadXml(retornoXml.OuterXml, consSitCTe);
retorno.SalvarXmlEmDisco(chave);
return(retorno);
}
public retInutCTe Inutilizar()
{
var inutCte = ClassesFactory.CriaInutCTe(_configInutiliza);
inutCte.Assinar();
inutCte.ValidarShcema();
inutCte.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlCteInutilizacao();
var retornoXml = webService.cteInutilizacaoCT(inutCte.CriaRequestWs());
var retorno = retInutCTe.LoadXml(retornoXml.OuterXml, inutCte);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public retInutCTe Inutilizar(ConfiguracaoServico configuracaoServico = null)
{
var inutCte = ClassesFactory.CriaInutCTe(_configInutiliza, configuracaoServico);
inutCte.Assinar(configuracaoServico);
inutCte.ValidarShcema(configuracaoServico);
inutCte.SalvarXmlEmDisco(configuracaoServico);
var webService = WsdlFactory.CriaWsdlCteInutilizacao(configuracaoServico);
var retornoXml = webService.cteInutilizacaoCT(inutCte.CriaRequestWs());
var retorno = retInutCTe.LoadXml(retornoXml.OuterXml, inutCte);
retorno.SalvarXmlEmDisco(inutCte.infInut.Id.Substring(2), configuracaoServico);
return(retorno);
}
public async Task <retInutCTe> InutilizarAsync()
{
var inutCte = ClassesFactory.CriaInutCTe(_configInutiliza);
inutCte.Assinar();
inutCte.ValidarShcema();
inutCte.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlCteInutilizacao();
var retornoXml = await webService.cteInutilizacaoCTAsync(inutCte.CriaRequestWs());
var retorno = retInutCTe.LoadXml(retornoXml.OuterXml, inutCte);
retorno.SalvarXmlEmDisco(inutCte.infInut.Id.Substring(2));
return(retorno);
}
public retEventoCTe Executar(CTeTipoEvento cTeTipoEvento, int sequenciaEvento, string chave, string cnpj, EventoContainer container, ConfiguracaoServico configuracaoServico = null)
{
var evento = FactoryEvento.CriaEvento(cTeTipoEvento, sequenciaEvento, chave, cnpj, container, configuracaoServico);
evento.Assina(configuracaoServico);
evento.ValidarSchema(configuracaoServico);
evento.SalvarXmlEmDisco(configuracaoServico);
var webService = WsdlFactory.CriaWsdlCteEvento(configuracaoServico);
var retornoXml = webService.cteRecepcaoEvento(evento.CriaXmlRequestWs());
var retorno = retEventoCTe.LoadXml(retornoXml.OuterXml, evento);
retorno.SalvarXmlEmDisco(configuracaoServico);
return(retorno);
}
public retEventoCTe Executar(CteEletronico cte, int sequenciaEvento, EventoContainer container, TipoEvento tipoEvento)
{
var evento = FactoryEvento.CriaEvento(cte, tipoEvento, sequenciaEvento, container);
evento.Assina();
evento.ValidarSchema();
evento.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlCteEvento();
var retornoXml = webService.cteRecepcaoEvento(evento.CriaXmlRequestWs());
var retorno = retEventoCTe.LoadXml(retornoXml.OuterXml, evento);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public async Task <retEventoCTe> Executar(TipoEvento tipoEvento, int sequenciaEvento, string chave, string cnpj, EventoContainer container)
{
var evento = FactoryEvento.CriaEvento(tipoEvento, sequenciaEvento, chave, cnpj, container);
evento.Assina();
evento.ValidarSchema();
evento.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlCteEvento();
var retornoXml = await webService.cteRecepcaoEvento(evento.CriaXmlRequestWs());
var retorno = retEventoCTe.LoadXml(retornoXml.OuterXml, evento);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public MDFeRetEnviMDFe MDFeRecepcao(long lote, MDFeEletronico mdfe)
{
var enviMDFe = ClassesFactory.CriaEnviMDFe(lote, mdfe);
enviMDFe.MDFe.Assina();
enviMDFe.Valida();
enviMDFe.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlMDFeRecepcao();
var retornoXml = webService.mdfeRecepcaoLote(enviMDFe.CriaXmlRequestWs());
var retorno = MDFeRetEnviMDFe.LoadXml(retornoXml.OuterXml, enviMDFe);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public MDFeRetEventoMDFe Executar(MDFeEletronico mdfe, byte sequenciaEvento, MDFeEventoContainer eventoContainer, MDFeTipoEvento tipoEvento)
{
var evento = FactoryEvento.CriaEvento(mdfe,
tipoEvento,
sequenciaEvento,
eventoContainer);
evento.ValidarSchema();
evento.SalvarXmlEmDisco(mdfe.Chave());
var webService = WsdlFactory.CriaWsdlMDFeRecepcaoEvento();
var retornoXml = webService.mdfeRecepcaoEvento(evento.CriaXmlRequestWs());
var retorno = MDFeRetEventoMDFe.LoadXml(retornoXml.OuterXml, evento);
retorno.SalvarXmlEmDisco(mdfe.Chave());
return(retorno);
}
public async Task <retEnviCte> CTeRecepcao(int lote, List <CTeEletronico> cteEletronicosList)
{
var instanciaConfiguracao = ConfiguracaoServico.Instancia;
var enviCte = ClassesFactory.CriaEnviCTe(lote, cteEletronicosList);
if (instanciaConfiguracao.tpAmb == TipoAmbiente.Homologacao)
{
foreach (var cte in enviCte.CTe)
{
const string razaoSocial = "CT-E EMITIDO EM AMBIENTE DE HOMOLOGACAO - SEM VALOR FISCAL";
cte.infCte.rem.xNome = razaoSocial;
cte.infCte.dest.xNome = razaoSocial;
}
}
foreach (var cte in enviCte.CTe)
{
cte.infCte.ide.tpEmis = instanciaConfiguracao.TipoEmissao;
cte.Assina();
cte.ValidaSchema();
cte.SalvarXmlEmDisco();
}
enviCte.ValidaSchema();
enviCte.SalvarXmlEmDisco();
var webService = WsdlFactory.CriaWsdlCteRecepcao();
OnAntesDeEnviar(enviCte);
var retornoXml = await webService.cteRecepcaoLote(enviCte.CriaRequestWs());
var retorno = retEnviCte.LoadXml(retornoXml.OuterXml, enviCte);
retorno.SalvarXmlEmDisco();
return(retorno);
}
public MDFeRetEventoMDFe Executar(Estado UFEmitente, string ChaveAcesso, string CPFCNPJEmitente, byte sequenciaEvento, MDFeEventoContainer eventoContainer, MDFeTipoEvento tipoEvento)
{
var evento = FactoryEvento.CriaEvento(UFEmitente,
ChaveAcesso,
CPFCNPJEmitente,
tipoEvento,
sequenciaEvento,
eventoContainer);
string chave = ChaveAcesso;
evento.ValidarSchema();
evento.SalvarXmlEmDisco(chave);
var webService = WsdlFactory.CriaWsdlMDFeRecepcaoEvento();
var retornoXml = webService.mdfeRecepcaoEvento(evento.CriaXmlRequestWs());
var retorno = MDFeRetEventoMDFe.LoadXml(retornoXml.OuterXml, evento);
retorno.SalvarXmlEmDisco(chave);
return(retorno);
}
/// <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
}
