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 static enviCTe PreparaEnvioCTe(int lote, List <CTeEletronico> cteEletronicosList, ConfiguracaoServico configuracaoServico = null)
{
var instanciaConfiguracao = configuracaoServico ?? ConfiguracaoServico.Instancia;
var enviCte = ClassesFactory.CriaEnviCTe(lote, cteEletronicosList, instanciaConfiguracao);
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(instanciaConfiguracao);
cte.infCTeSupl = cte.QrCode(instanciaConfiguracao.X509Certificate2, Encoding.UTF8, instanciaConfiguracao.IsAdicionaQrCode);
cte.ValidaSchema(instanciaConfiguracao);
cte.SalvarXmlEmDisco(instanciaConfiguracao);
}
enviCte.ValidaSchema(instanciaConfiguracao);
enviCte.SalvarXmlEmDisco(instanciaConfiguracao);
return(enviCte);
}
public MDFeRetEventoMDFe MDFeEventoPagamentoOperacaoTransporte(MDFeEletronico mdfe, byte sequenciaEvento, string protocolo,
int qtdViagens, int nroViagem)
{
var pagamento = ClassesFactory.CriaEvPagtoOperMDFe(protocolo, mdfe, qtdViagens, nroViagem);
return(new ServicoController().Executar(mdfe, sequenciaEvento, pagamento, MDFeTipoEvento.PagamentoOperacaoTransporte));
}
public MDFeRetEventoMDFe MDFeEventoIncluirDFe(MDFeEletronico mdfe, byte sequenciaEvento, string protocolo,
string codigoMunicipioCarregamento, string nomeMunicipioCarregamento, List <MDFeInfDocInc> informacoesDocumentos)
{
var inclusao = ClassesFactory.CriaEvIncDFeMDFe(protocolo, codigoMunicipioCarregamento, nomeMunicipioCarregamento, informacoesDocumentos);
return(new ServicoController().Executar(mdfe, sequenciaEvento, inclusao, MDFeTipoEvento.InclusaoDFe));
}
public async Task <retEventoCTe> CancelarAsync(ConfiguracaoServico configuracaoServico = null)
{
var eventoCancelar = ClassesFactory.CriaEvCancCTe(_justificativa, _numeroProtocolo);
var retorno = await new ServicoController().ExecutarAsync(_cte, _sequenciaEvento, eventoCancelar, CTeTipoEvento.Cancelamento, configuracaoServico);
return(retorno);
}
public MDFeRetEventoMDFe MDFeEventoIncluirCondutor(MDFeEletronico mdfe, byte sequenciaEvento, string nome, string cpf)
{
var incluirCodutor = ClassesFactory.CriaEvIncCondutorMDFe(nome, cpf);
var retorno = new ServicoController().Executar(mdfe, sequenciaEvento, incluirCodutor, MDFeTipoEvento.InclusaoDeCondutor);
return(retorno);
}
public async Task <retEventoCTe> AdicionarCorrecoes()
{
var eventoCorrecao = ClassesFactory.CriaEvCCeCTe(_infCorrecaos);
var retorno = await new ServicoController().Executar(_cte, _sequenciaEvento, eventoCorrecao, TipoEvento.CartaCorrecao);
return(retorno);
}
public MDFeRetEventoMDFe MDFeEventoEncerramento(MDFeEletronico mdfe, byte sequenciaEvento, string protocolo)
{
var encerramento = ClassesFactory.CriaEvEncMDFe(mdfe, protocolo);
var retorno = new ServicoController().Executar(mdfe, sequenciaEvento, encerramento, MDFeTipoEvento.Encerramento);
return(retorno);
}
public async Task <retEventoCTe> AdicionarCorrecoesAsync(ConfiguracaoServico configuracaoServico = null)
{
var eventoCorrecao = ClassesFactory.CriaEvCCeCTe(_infCorrecaos);
var retorno = await new ServicoController().ExecutarAsync(_cte, _sequenciaEvento, eventoCorrecao, CTeTipoEvento.CartaCorrecao, configuracaoServico);
return(retorno);
}
public retEventoCTe Cancelar()
{
var eventoCancelar = ClassesFactory.CriaEvCancCTe(_justificativa, _numeroProtocolo);
var retorno = new ServicoController().Executar(_cte, _sequenciaEvento, eventoCancelar, TipoEvento.Cancelamento);
return(retorno);
}
public retEventoCTe Discordar()
{
var eventoDiscordar = ClassesFactory.CriaEvPrestDesacordo(_indicadorDesacordo, _observacao);
var retorno = new ServicoController().Executar(TipoEvento.Desacordo, _sequenciaEvento, _chave, _cnpj, eventoDiscordar);
return(retorno);
}
public MDFeRetEventoMDFe MDFeEventoCancelar(MDFeEletronico mdfe, byte sequenciaEvento, string protocolo, string justificativa)
{
var cancelamento = ClassesFactory.CriaEvCancMDFe(protocolo, justificativa);
var retorno = new ServicoController().Executar(mdfe, sequenciaEvento, cancelamento, MDFeTipoEvento.Cancelamento);
return(retorno);
}
public MDFeRetEventoMDFe MDFeEventoEncerramento(Estado UFEmitente, string ChaveAcesso, string CPFCNPJEmitente, Estado estadoEncerramento, long codigoMunicipioEncerramento, byte sequenciaEvento, string protocolo)
{
var encerramento = ClassesFactory.CriaEvEncMDFe(estadoEncerramento, codigoMunicipioEncerramento, protocolo);
var retorno = new ServicoController().Executar(UFEmitente, ChaveAcesso, CPFCNPJEmitente, sequenciaEvento, encerramento, MDFeTipoEvento.Encerramento);
return(retorno);
}
public async Task <retEventoCTe> DiscordarAsync(ConfiguracaoServico configuracaoServico = null)
{
var eventoDiscordar = ClassesFactory.CriaEvPrestDesacordo(_indicadorDesacordo, _observacao);
var retorno = await new ServicoController().ExecutarAsync(CTeTipoEvento.Desacordo, _sequenciaEvento, _chave, _cnpj, eventoDiscordar, configuracaoServico);
return(retorno);
}
public retEventoCTe Discordar(ConfiguracaoServico configuracaoServico = null)
{
var eventoDiscordar = ClassesFactory.CriaEvPrestDesacordo(_indicadorDesacordo, _observacao);
EventoEnviado = FactoryEvento.CriaEvento(CTeTipoEvento.Desacordo, _sequenciaEvento, _chave, _cnpj, eventoDiscordar, configuracaoServico);
RetornoSefaz = new ServicoController().Executar(CTeTipoEvento.Desacordo, _sequenciaEvento, _chave, _cnpj, eventoDiscordar, configuracaoServico);
return(RetornoSefaz);
}
public async Task <retEventoCTe> CancelarAsync(ConfiguracaoServico configuracaoServico = null)
{
var evento = ClassesFactory.CriaEvCancCTe(_justificativa, _numeroProtocolo);
EventoEnviado = FactoryEvento.CriaEvento(CTeTipoEvento.Cancelamento, _sequenciaEvento, _cte.Chave(), _cte.infCte.emit.CNPJ, evento, configuracaoServico);
RetornoSefaz = await new ServicoController().ExecutarAsync(_cte, _sequenciaEvento, evento, CTeTipoEvento.Cancelamento, configuracaoServico);
return(RetornoSefaz);
}
public async Task <retEventoCTe> AdicionarCorrecoesAsync(ConfiguracaoServico configuracaoServico = null)
{
var eventoCorrecao = ClassesFactory.CriaEvCCeCTe(_infCorrecaos);
EventoEnviado = FactoryEvento.CriaEvento(CTeTipoEvento.CartaCorrecao, _sequenciaEvento, _cte.Chave(), _cte.infCte.emit.CNPJ, eventoCorrecao, configuracaoServico);
RetornoSefaz = await new ServicoController().ExecutarAsync(_cte, _sequenciaEvento, eventoCorrecao, CTeTipoEvento.CartaCorrecao, configuracaoServico);
return(RetornoSefaz);
}
public MDFeRetEventoMDFe MDFeEventoPagamentoOperacao(Classes.Informacoes.MDFe mdfe, byte sequencia,
string protocolo, infViagens infViagens, List <infPag> infPagamentos)
{
var eventoPagamento = ClassesFactory.CriaEvPagtoOperMDFe(
protocolo
, infViagens
, infPagamentos
);
return(new ServicoController().Executar(mdfe, sequencia, eventoPagamento, MDFeTipoEvento.PagamentoOperacaoMDFe));
}
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 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 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 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 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 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 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 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 <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 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);
}
