private void ValidarSchema(envEvento entity)
{
var caminhoSchema = _emisorEmissorServicoConfig.DiretorioSchemaXsd;
if (!Directory.Exists(caminhoSchema))
{
throw new Exception("Diretório de Schemas não encontrado: \n" + caminhoSchema);
}
// Define o tipo de validação
var cfg = new XmlReaderSettings {
ValidationType = ValidationType.Schema
};
//Listar arquivos XSD e inclui-las na validação
var list = ObterListaNomeSchemas().ToList();
list.ForEach(n => { cfg.Schemas.Add(null, Path.Combine(caminhoSchema, n)); });
cfg.ValidationEventHandler += ValidationEventHandler;
var xml = Utils.ObterStringXML(entity);
var reader = XmlReader.Create(new StringReader(xml), cfg);
var document = new XmlDocument();
document.Load(reader);
//Valida xml
document.Validate(ValidationEventHandler);
}
private string GerarXmlEvento(string chaveAcesso, eTipoEventoNFe tipoEvento, string justificativa = null)
{
if (tipoEvento == eTipoEventoNFe.OperacaoNaoRealizada && justificativa == null)
{
throw new ArgumentNullException("Justificativa deve ser informada");
}
if (tipoEvento != eTipoEventoNFe.OperacaoNaoRealizada)
{
justificativa = null;
}
var infEvento = new infEventoEnv
{
chNFe = chaveAcesso,
CNPJ = config.Emitente.CNPJ,
CPF = config.Emitente.CPF,
cOrgao = eUF.AN,
dhEvento = DateTime.Now,
nSeqEvento = 1,
tpAmb = config.TipoAmbiente,
tpEvento = tipoEvento,
verEvento = config.VersaoManifestacaoDestinatario.Descricao(),
Id = "ID" + ((int)tipoEvento) + chaveAcesso + nSeqEvento.ToString().PadLeft(2, '0'),
detEvento = new detEvento()
{
versao = config.VersaoManifestacaoDestinatario.Descricao(),
descEvento = tipoEvento.Descricao().RemoverAcentos()
}
};
var evento = new evento
{
versao = config.VersaoManifestacaoDestinatario.Descricao(),
infEvento = infEvento
};
evento.Assinar(ObterCertificado.Obter(config.ConfigCertificado), config.ConfigCertificado.SignatureMethodSignedXml, config.ConfigCertificado.DigestMethodReference);
var pedEvento = new envEvento
{
versao = config.VersaoManifestacaoDestinatario.Descricao(),
idLote = 1,
evento = new List <evento> {
evento
}
};
var xmlEvento = XmlUtils.ClasseParaXmlString <envEvento>(pedEvento);
return(xmlEvento);
}
/// <summary>
/// Obter mensagem Soap em formato Xml
/// <para>Corpo da mensagem compativel com a especificação SOAP e requisitos Sefaz</para>
/// </summary>
/// <param name="urlWsdl">Endereço WSDL do serviço</param>
/// <param name="entity"></param>
/// <example></example>
/// <returns></returns>
protected virtual string ObterCorpoMensagemSoap(string urlWsdl, envEvento entity)
{
var xmlCorpo = Utils.ObterStringXML(entity);
var stringBuilder = new StringBuilder();
stringBuilder.Append("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>");
stringBuilder.Append(
"<soap:Envelope xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">");
stringBuilder.Append("<soap:Body>");
stringBuilder.Append("<nfeDadosMsg xmlns=\"" + urlWsdl + "\">" + xmlCorpo + "</nfeDadosMsg>");
stringBuilder.Append("</soap:Body>");
stringBuilder.Append("</soap:Envelope>");
var msg = stringBuilder.ToString();
return(msg);
}
/// <summary>
/// Salvar arquivo Xml
/// </summary>
private void SalvarPedido(envEvento entity)
{
if (!_emisorEmissorServicoConfig.SalvarArquivoRetorno)
{
return;
}
//SalvarArquivo
if (string.IsNullOrWhiteSpace(_emisorEmissorServicoConfig.DiretorioArquivoRetornoXml))
{
throw new InvalidOperationException("Informe um diretório válido.");
}
var nomeArq = $"{_idlote}-ped-eve.xml";
var caminho = Path.Combine(_emisorEmissorServicoConfig.DiretorioArquivoRetornoXml, "Cancelamento", "Enviados");
var xml = Utils.ObterStringXML(entity);
Utils.EscreverArquivo(caminho, nomeArq, xml);
}
private async Task <retEnvEvento> Cancelar(List <evento> eventos, eModeloDocumento modeloDoc)
{
var pedEvento = new envEvento
{
versao = versao,
idLote = 1,
evento = eventos
};
foreach (var eventoTmp in eventos)
{
eventoTmp.infEvento.Id = "ID" + ((int)eventoTmp.infEvento.tpEvento) + eventoTmp.infEvento.chNFe +
eventoTmp.infEvento.nSeqEvento.ToString().PadLeft(2, '0');
var _certificado = ObterCertificado.Obter(cfgServico.ConfigCertificado);
eventoTmp.Assinar(_certificado, cfgServico.ConfigCertificado.SignatureMethodSignedXml, cfgServico.ConfigCertificado.DigestMethodReference);
}
var xmlEvento = XmlUtils.ClasseParaXmlString <envEvento>(pedEvento);
var arqEnv = Path.Combine("Logs", $"{DateTime.Now.Ticks}-ped-eve.xml");
await storage.SaveAsync(arqEnv, xmlEvento);
var sefazUrl = Fabrica.FabricarUrl.ObterUrl(eTipoServico.CancelarNFe, cfgServico.TipoAmbiente, modeloDoc, cfgServico.UF);
var envelope = Fabrica.SoapEnvelopeFabrica.FabricarEnvelope(eTipoServico.CancelarNFe, xmlEvento);
var retornoXmlString = await transmitir.TransmitirAsync(sefazUrl, envelope);
var retornoXmlStringLimpa = Soap.LimparEnvelope(retornoXmlString, "retEnvEvento").OuterXml;
var arqRet = Path.Combine("Logs", $"{DateTime.Now.Ticks}-ret-eve.xml");
await storage.SaveAsync(arqRet, retornoXmlStringLimpa);
var retEnvEvento = new retEnvEvento().CarregarDeXmlString(retornoXmlStringLimpa, xmlEvento);
return(retEnvEvento);
}
/// <summary>
/// Obter Dados
/// </summary>
/// <returns></returns>
private envEvento ObterDados()
{
var lstEventos = new List <evento>();
foreach (var item in _eventosBuilder)
{
lstEventos.Add(new evento
{
versao = _versao.ObterVersaoServico(),
infEvento = new infEventoEnv
{
CPF = item.Cpfcnpj.Length == 11 ? item.Cpfcnpj : null,
CNPJ = item.Cpfcnpj.Length == 14 ? item.Cpfcnpj : null,
cOrgao = _emisorEmissorServicoConfig.Estado,
tpAmb = _emisorEmissorServicoConfig.Ambiente,
chNFe = item.ChaveNFe,
dhEvento = DateTime.Now,
tpEvento = 110111, //Codigo do evento de cancelamento
nSeqEvento = item.SeqEvento,
verEvento = _versao.ObterVersaoServico(),
detEvento = new detEvento
{
nProt = item.ProtAutorizacao,
versao = _versao.ObterVersaoServico(),
xJust = item.Justificativa
},
Id = "ID" + 110111 + item.ChaveNFe + item.SeqEvento.ToString().PadLeft(2, '0')
}
});
}
var eventos = new envEvento {
versao = _versao.ObterVersaoServico(), evento = lstEventos, idLote = _idlote
};
return(eventos);
}
/// <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
}
/// <summary>
/// Envia um evento genérico
/// </summary>
/// <param name="idlote"></param>
/// <param name="eventos"></param>
/// <param name="servicoEvento">Tipo de serviço do evento: valores válidos: RecepcaoEventoCancelmento, RecepcaoEventoCartaCorrecao, RecepcaoEventoEpec e RecepcaoEventoManifestacaoDestinatario</param>
/// <returns>Retorna um objeto da classe RetornoRecepcaoEvento com o retorno do serviço RecepcaoEvento</returns>
private RetornoRecepcaoEvento RecepcaoEvento(int idlote, List <evento> eventos, ServicoNFe servicoEvento)
{
var listaEventos = new List <ServicoNFe>
{
ServicoNFe.RecepcaoEventoCartaCorrecao,
ServicoNFe.RecepcaoEventoCancelmento,
ServicoNFe.RecepcaoEventoEpec,
ServicoNFe.RecepcaoEventoManifestacaoDestinatario
};
if (
!listaEventos.Contains(servicoEvento))
{
throw new Exception(string.Format("Serviço {0} é inválido para o método {1}!\nServiços válidos: \n • {2}", servicoEvento,
MethodBase.GetCurrentMethod().Name, string.Join("\n • ", listaEventos.ToArray())));
}
var versaoServico = servicoEvento.VersaoServicoParaString(_cFgServico.VersaoRecepcaoEventoCceCancelamento);
#region Cria o objeto wdsl para consulta
var ws = CriarServico(servicoEvento);
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(servicoEvento, _cFgServico.VersaoRecepcaoEventoCceCancelamento, 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
}
/// <summary>
/// Recebe um objeto envEvento e devolve a string no formato XML
/// </summary>
/// <param name="pedEvento">Objeto do tipo envEvento</param>
/// <returns>string com XML no do objeto envEvento</returns>
public static string ObterXmlString(this envEvento pedEvento)
{
return(FuncoesXml.ClasseParaXmlString(pedEvento));
}
public async Task <retEnvEvento> TransmitirCorrecao(IList <InfoCartaCorrecao> infos)
{
if (infos == null || infos.Count <= 0)
{
throw new Exception("Informações da NFe não encontrada");
}
if (infos.Count > 20)
{
throw new Exception("No máximo 20 NFes podem ser Corrigidas");
}
List <evento> eventos = new List <evento>();
foreach (var item in infos)
{
var chave = item.ChaveAcesso;
var correcao = item.Correcao;
var nSeqEvento = item.nSeqEvento;
chave = chave.Replace("NFe", "");
eModeloDocumento _modeloDocumento = chave.Substring(20, 2).ModeloDocumento();
if (item.Correcao.Length < 15 || item.Correcao.Length > 1000)
{
throw new FalhaValidacaoException("A descrição da correção deve conter entre 15 e 1000 caracteres");
}
if (_modeloDocumento != eModeloDocumento.NFe)
{
throw new FalhaValidacaoException("Somente NFe pode ter Carta Correção");
}
var infEvento = new infEventoEnv
{
chNFe = chave,
CNPJ = cfgServico.Emitente.CNPJ,
CPF = cfgServico.Emitente.CPF,
cOrgao = cfgServico.UF,
dhEvento = DateTime.Now,
nSeqEvento = nSeqEvento,
tpAmb = cfgServico.TipoAmbiente,
tpEvento = eTipoEventoNFe.NFeCartaCorrecao,
verEvento = _versao,
detEvento = new detEvento()
{
versao = _versao,
descEvento = "Carta de Correção",
xCorrecao = correcao
}
};
var evento = new evento {
versao = _versao, infEvento = infEvento
};
eventos.Add(evento);
}
foreach (var eventoTmp in eventos)
{
eventoTmp.infEvento.Id = "ID" + ((int)eventoTmp.infEvento.tpEvento) + eventoTmp.infEvento.chNFe +
eventoTmp.infEvento.nSeqEvento.ToString().PadLeft(2, '0');
var _certificado = ObterCertificado.Obter(cfgServico.ConfigCertificado);
eventoTmp.Assinar(_certificado, cfgServico.ConfigCertificado.SignatureMethodSignedXml, cfgServico.ConfigCertificado.DigestMethodReference);
}
var pedEvento = new envEvento
{
versao = _versao,
idLote = 1,
evento = eventos
};
var xmlEvento = XmlUtils.ClasseParaXmlString <envEvento>(pedEvento);
var arqEnv = Path.Combine("Logs", Arquivo.MontarNomeArquivo("ped-eve.xml", cfgServico));
await storage.SaveAsync(arqEnv, xmlEvento);
var sefazUrl = Fabrica.FabricarUrl.ObterUrl(eTipoServico.CartaCorrecao, cfgServico.TipoAmbiente, eModeloDocumento.NFe, cfgServico.UF);
var envelope = Fabrica.SoapEnvelopeFabrica.FabricarEnvelope(eTipoServico.CartaCorrecao, xmlEvento);
var retornoXmlString = await transmitir.TransmitirAsync(sefazUrl, envelope);
var retornoXmlStringLimpa = Soap.LimparEnvelope(retornoXmlString, "retEnvEvento").OuterXml;
var arqRet = Path.Combine("Logs", Arquivo.MontarNomeArquivo("ret-eve.xml", cfgServico));
await storage.SaveAsync(arqRet, retornoXmlStringLimpa);
var retorno = new retEnvEvento().CarregarDeXmlString(retornoXmlStringLimpa, xmlEvento);
return(retorno);
}
