protected virtual infNFe GetInf(int numero, ModeloDocumento modelo, VersaoServico versao)
{
var infNFe = new infNFe
{
versao = Auxiliar.VersaoServicoParaString(versao),
ide = GetIdentificacao(numero, modelo, versao),
emit = GetEmitente(),
dest = GetDestinatario(versao),
total = GetTotal(versao),
transp = GetTransporte()
};
if (infNFe.ide.mod == ModeloDocumento.NFe & versao == VersaoServico.ve310)
{
infNFe.cobr = GetCobranca(); //V3.00 Somente
}
if (infNFe.ide.mod == ModeloDocumento.NFCe)
{
infNFe.pag = GetPagamento(); //NFCe Somente
}
for (var i = 0; i < 1; i++)
{
infNFe.det.Add(GetDetalhe(i));
}
return(infNFe);
}
private static Classes.NFe GetNf(int numero, ModeloDocumento modelo, VersaoServico versao)
{
Classes.NFe nf = new Classes.NFe {
infNFe = GetInf(numero, modelo, versao)
};
return(nf);
}
protected virtual ide GetIdentificacao(int numero, ModeloDocumento modelo, VersaoServico versao)
{
var ide = new ide
{
cUF = Estado.SE,
natOp = "VENDA",
indPag = IndicadorPagamento.ipVista,
mod = modelo,
serie = 1,
nNF = numero,
tpNF = TipoNFe.tnSaida,
cMunFG = 2802908,
tpEmis = _configuracoes.CfgServico.tpEmis,
tpImp = TipoImpressao.tiRetrato,
cNF = "1234",
tpAmb = _configuracoes.CfgServico.tpAmb,
finNFe = FinalidadeNFe.fnNormal,
verProc = "3.000"
};
if (ide.tpEmis != TipoEmissao.teNormal)
{
ide.dhCont = DateTime.Now.ToString(versao == VersaoServico.ve310 ? "yyyy-MM-ddTHH:mm:sszzz" : "yyyy-MM-ddTHH:mm:ss");
ide.xJust = "TESTE DE CONTIGÊNCIA PARA NFe/NFCe";
}
#region V2.00
if (versao == VersaoServico.ve200)
{
ide.dEmi = DateTime.Today.ToString("yyyy-MM-dd"); //Mude aqui para enviar a nfe vinculada ao EPEC, V2.00
ide.dSaiEnt = DateTime.Today.ToString("yyyy-MM-dd");
}
#endregion
#region V3.00
if (versao != VersaoServico.ve310)
{
return(ide);
}
ide.idDest = DestinoOperacao.doInterna;
ide.dhEmi = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzz"); //Mude aqui para enviar a nfe vinculada ao EPEC, V3.10
if (ide.mod == ModeloDocumento.NFe)
{
ide.dhSaiEnt = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzz");
}
else
{
ide.tpImp = TipoImpressao.tiNFCe;
}
ide.procEmi = ProcessoEmissao.peAplicativoContribuinte;
ide.indFinal = ConsumidorFinal.cfConsumidorFinal; //NFCe: Tem que ser consumidor Final
ide.indPres = PresencaComprador.pcPresencial; //NFCe: deve ser 1 ou 4
#endregion
return(ide);
}
public DFeCabecalho(Estado codigoUF, VersaoServico versaoServico, ITagCabecalho tagCabecalho, string namespaceHeader)
{
CodigoUF = codigoUF;
VersaoServico = versaoServico;
NamespaceHeader = namespaceHeader;
TagCabecalho = tagCabecalho;
}
protected virtual dest GetDestinatario(VersaoServico versao, ModeloDocumento modelo)
{
var dest = new dest(versao)
{
CNPJ = "99999999000191",
//CPF = "99999999999",
};
if (modelo == ModeloDocumento.NFe)
{
dest.xNome = "NF-E EMITIDA EM AMBIENTE DE HOMOLOGACAO - SEM VALOR FISCAL"; //Obrigatório para NFe e opcional para NFCe
dest.enderDest = GetEnderecoDestinatario(); //Obrigatório para NFe e opcional para NFCe
}
//if (versao == VersaoServico.ve200)
// dest.IE = "ISENTO";
if (versao == VersaoServico.ve200)
{
return(dest);
}
dest.indIEDest = indIEDest.NaoContribuinte; //NFCe: Tem que ser não contribuinte V3.00 Somente
dest.email = "*****@*****.**"; //V3.00 Somente
return(dest);
}
private static pag GetPagamento(ICMSTot icmsTot, VersaoServico versao)
{
decimal valorPagto = (icmsTot.vNF / 2).Arredondar(2);
if (versao != VersaoServico.Versao400) // difernte de versão 4 retorna isso
{
return(new pag {
tPag = FormaPagamento.fpDinheiro, vPag = valorPagto
});
}
// igual a versão 4 retorna isso
return(new pag
{
detPag = new List <detPag>
{
new detPag {
tPag = FormaPagamento.fpCreditoLoja, vPag = valorPagto
},
new detPag {
tPag = FormaPagamento.fpCreditoLoja, vPag = icmsTot.vNF - valorPagto
}
}
});
}
protected virtual dest GetDestinatario(VersaoServico versao, ModeloDocumento modelo)
{
// TODO: CPF na nota?
var dest = new dest(versao)
{
CPF = "07506178966",
xNome = nfeEmitadaHomolog,
indIEDest = indIEDest.NaoContribuinte,
email = "*****@*****.**"
};
//if (modelo == ModeloDocumento.NFe)
//{
// dest.xNome = "NF-E EMITIDA EM AMBIENTE DE HOMOLOGACAO - SEM VALOR FISCAL"; //Obrigatório para NFe e opcional para NFCe
// dest.enderDest = GetEnderecoDestinatario(); //Obrigatório para NFe e opcional para NFCe
//}
////if (versao == VersaoServico.ve200)
//// dest.IE = "ISENTO";
//if (versao == VersaoServico.ve200) return dest;
//dest.indIEDest = indIEDest.NaoContribuinte; //NFCe: Tem que ser não contribuinte V3.00 Somente
//dest.email = "*****@*****.**"; //V3.00 Somente
return(dest);
}
public EnderecoConsultaPublicaNfce(Estado estado, TipoAmbiente tipoAmbiente, TipoUrlConsultaPublica tipoUrlConsultaPublica, string url, VersaoServico versaoServico = VersaoServico.ve310)
{
TipoAmbiente = tipoAmbiente;
Estado = estado;
TipoUrlConsultaPublica = tipoUrlConsultaPublica;
Url = url;
VersaoServico = versaoServico;
}
/// <summary>
/// Retorna verdadeiro para as UFs que utilizam SVC-AN, caso o tipo de emissão seja SVC-AN e o documento seja NF-e
/// </summary>
/// <param name="cfgServico"></param>
/// <returns></returns>
public static bool UsaSvcanNFe4(this ConfiguracaoServico cfgServico, VersaoServico versaoServico)
{
return(Enderecador.EstadosQueUsamSvcAnParaNfe().Contains(cfgServico.cUF) &&
cfgServico.tpEmis == TipoEmissao.teSVCAN &&
cfgServico.ModeloDocumento == ModeloDocumento.NFe &&
versaoServico == VersaoServico.ve400
);
}
protected virtual Classes.NFe GetNf(int numero, ModeloDocumento modelo, VersaoServico versao)
{
var nf = new Classes.NFe {
infNFe = GetInf(numero, modelo, versao)
};
return(nf);
}
public static string GetVersaoString(this VersaoServico versaoServico)
{
var codigoString = versaoServico.ToString();
var codigoFormatado = codigoString.Substring(6, 3);
codigoFormatado = codigoFormatado.Insert(1, ".");
return(codigoFormatado);
}
public EnderecoConsultaPublicaNfce(TipoAmbiente tipoAmbiente, Estado estado, TipoUrlConsultaPublica tipoUrlConsultaPublica, VersaoServico versaoServico, VersaoQrCode versaoQrCode, string url)
{
TipoAmbiente = tipoAmbiente;
Estado = estado;
TipoUrlConsultaPublica = tipoUrlConsultaPublica;
Url = url;
VersaoServico = versaoServico;
VersaoQrCode = versaoQrCode;
}
public static string[] Valida(ServicoNFe servicoNFe, VersaoServico versaoServico, string stringXml, bool loteNfe = true, string pathSchema = null)
{
var falhas = new StringBuilder();
if (!Directory.Exists(pathSchema))
{
throw new Exception("Diretório de Schemas não encontrado: \n" + pathSchema);
}
var arquivoSchema = Path.Combine(pathSchema, ObterArquivoSchema(servicoNFe, versaoServico, stringXml, loteNfe));
// Define o tipo de validação
var cfg = new XmlReaderSettings {
ValidationType = ValidationType.Schema
};
// Carrega o arquivo de esquema
var schemas = new XmlSchemaSet();
schemas.XmlResolver = new XmlUrlResolver();
cfg.Schemas = schemas;
// Quando carregar o eschema, especificar o namespace que ele valida
// e a localização do arquivo
schemas.Add(null, arquivoSchema);
// Especifica o tratamento de evento para os erros de validacao
cfg.ValidationEventHandler += delegate(object sender, ValidationEventArgs args)
{
falhas.AppendLine($"[{args.Severity}] - {args.Message} {args.Exception?.Message} na linha {args.Exception.LineNumber} posição {args.Exception.LinePosition} em {args.Exception.SourceUri}".ToString());
};
// cria um leitor para validação
var validator = XmlReader.Create(new StringReader(stringXml), cfg);
try
{
// Faz a leitura de todos os dados XML
while (validator.Read())
{
}
}
catch
{
}
finally
{
validator.Close();
}
if (falhas.Length > 0)
{
throw new ValidacaoSchemaException($"Ocorreu o seguinte erro durante a validação XML: {Environment.NewLine}{falhas}");
}
return(falhas.ToString().Trim().Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries));
}
public EnderecoServico(ServicoNFe servicoNFe, VersaoServico versaoServico, TipoAmbiente tipoAmbiente, TipoEmissao tipoEmissao, Estado estado, ModeloDocumento modeloDocumento, string url)
{
ServicoNFe = servicoNFe;
VersaoServico = versaoServico;
TipoAmbiente = tipoAmbiente;
TipoEmissao = tipoEmissao;
Estado = estado;
Url = url;
ModeloDocumento = modeloDocumento;
}
public EnderecoServico(ServicoNFe servicoNFe, VersaoServico versaoServico, TipoAmbiente tipoAmbiente, TipoEmissao tipoEmissao, Estado estado, ModeloDocumento modeloDocumento, string url)
{
ServicoNFe = servicoNFe;
VersaoServico = versaoServico;
TipoAmbiente = tipoAmbiente;
TipoEmissao = tipoEmissao;
Estado = estado;
Url = url;
ModeloDocumento = modeloDocumento;
}
protected ServAutorzTemplate(EmissorServicoConfig emissorServicoConfig, X509Certificate2 certificado, int idlote,
ICollection <NFe> nFes, VersaoServico versao, bool compactarMensagem = false)
{
_certificadoDigital = certificado ?? throw new ArgumentNullException(nameof(certificado));
_emisorEmissorServicoConfig = emissorServicoConfig ?? throw new ArgumentNullException(nameof(emissorServicoConfig));
_servicoBase = new ServHttpSoapBase(emissorServicoConfig, certificado, NomeServico);
_nFes = nFes;
_idlote = idlote;
_compactarMensagem = compactarMensagem;
_versao = versao;
}
public EmissorServicoConfig(VersaoServico versaoServico, Estado estado, TipoAmbiente ambiente,
IndicadorSincronizacao indicadorSincronizacao = IndicadorSincronizacao.Sincrono, int timeOut = 60000)
{
VersaoServico = versaoServico;
IndicadorSincronizacao = indicadorSincronizacao;
Estado = estado;
Ambiente = ambiente;
TimeOut = timeOut;
ValidaConfiguracaoBasica();
CarregarConfigServ();
}
protected ServCancTemplate(EmissorServicoConfig emissorServicoConfig, X509Certificate2 certificado, int idlote,
ICollection <EventoBuilder> eventoBuilder, VersaoServico versao, ModeloDocumento modelo = ModeloDocumento.NFe)
{
_certificadoDigital = certificado ?? throw new ArgumentNullException(nameof(certificado));
_emisorEmissorServicoConfig = emissorServicoConfig ?? throw new ArgumentNullException(nameof(emissorServicoConfig));
_servicoBase = new ServHttpSoapBase(emissorServicoConfig, certificado, NomeServico);
_versao = versao;
_modelo = modelo;
_idlote = idlote;
_eventosBuilder = eventoBuilder;
}
internal static string ObterArquivoSchema(ServicoNFe servicoNFe, TipoRecepcaoEvento tipoRecepcaoEvento, VersaoServico versaoServico, bool loteNfe = true)
{
switch (servicoNFe)
{
case ServicoNFe.NfeRecepcao:
return loteNfe ? "enviNFe_v2.00.xsd" : "nfe_v2.00.xsd";
case ServicoNFe.RecepcaoEvento:
switch (tipoRecepcaoEvento)
{
case TipoRecepcaoEvento.Cancelmento:
return "envEventoCancNFe_v1.00.xsd";
case TipoRecepcaoEvento.CartaCorrecao:
return "envCCe_v1.00.xsd";
case TipoRecepcaoEvento.Epec:
return "envEPEC_v1.00.xsd";
}
break;
case ServicoNFe.NfeInutilizacao:
switch (versaoServico)
{
case VersaoServico.ve200:
return "inutNFe_v2.00.xsd";
case VersaoServico.ve310:
return "inutNFe_v3.10.xsd";
}
break;
case ServicoNFe.NfeConsultaProtocolo:
switch (versaoServico)
{
case VersaoServico.ve200:
return "consSitNFe_v2.01.xsd";
case VersaoServico.ve310:
return "consSitNFe_v3.10.xsd";
}
break;
case ServicoNFe.NfeStatusServico:
switch (versaoServico)
{
case VersaoServico.ve200:
return "consStatServ_v2.00.xsd";
case VersaoServico.ve310:
return "consStatServ_v3.10.xsd";
}
break;
case ServicoNFe.NFeAutorizacao:
return loteNfe ? "enviNFe_v3.10.xsd" : "nfe_v3.10.xsd";
case ServicoNFe.NfeConsultaCadastro:
return "consCad_v2.00.xsd";
case ServicoNFe.NfeDownloadNF:
return "downloadNFe_v1.00.xsd";
}
return null;
}
/// <summary>
/// Inicializa objeto
/// </summary>
/// <param name="emissorServicoConfig">Configuração do Emissor</param>
/// <param name="certificado">Certificado Digital</param>
/// <param name="versao">Versao do Serviço</param>
/// <param name="modelo"></param>
protected ServConsStatTemplate(EmissorServicoConfig emissorServicoConfig, X509Certificate2 certificado, VersaoServico versao,
ModeloDocumento modelo = ModeloDocumento.NFe)
{
if (certificado == null)
{
throw new ArgumentNullException(nameof(certificado));
}
_emisorEmissorServicoConfig = emissorServicoConfig ?? throw new ArgumentNullException(nameof(emissorServicoConfig));
_servicoBase = new ServHttpSoapBase(emissorServicoConfig, certificado, NomeServico);
_versao = versao;
_modelo = modelo;
}
protected ServAutorzTemplate(EmissorServicoConfig emissorServicoConfig, X509Certificate2 certificado, string xml,
VersaoServico versao, bool compactarMensagem = false)
{
_certificadoDigital = certificado ?? throw new ArgumentNullException(nameof(certificado));
_emisorEmissorServicoConfig = emissorServicoConfig ?? throw new ArgumentNullException(nameof(emissorServicoConfig));
_servicoBase = new ServHttpSoapBase(emissorServicoConfig, certificado, NomeServico);
_nFes = null;
_idlote = 1;
_compactarMensagem = compactarMensagem;
_versao = versao;
_xmlNfe = xml;
}
public static string VersaoServicoParaString(VersaoServico versao)
{
switch (versao)
{
case VersaoServico.ve100:
return "1.00";
case VersaoServico.ve200:
return "2.00";
case VersaoServico.ve310:
return "3.10";
}
return null;
}
protected ServInutTemplate(EmissorServicoConfig emissorServicoConfig, X509Certificate2 certificado, string cnpj, int ano,
ModeloDocumento modelo, VersaoServico versao, int serie, int numeroInicial, int numeroFinal, string justificativa)
{
_emisorEmissorServicoConfig = emissorServicoConfig;
_certificadoDigital = certificado;
_cnpj = cnpj;
_ano = ano;
_modelo = modelo;
_serie = serie;
_numeroInicial = numeroInicial;
_numeroFinal = numeroFinal;
_justificativa = justificativa;
_versao = versao;
}
public static void Valida(ServicoNFe servicoNFe, VersaoServico versaoServico, string stringXml, bool loteNfe = true)
{
var pathSchema = ConfiguracaoServico.Instancia.DiretorioSchemas;
if (!Directory.Exists(pathSchema))
{
throw new Exception("Diretório de Schemas não encontrado: \n" + pathSchema);
}
var arquivoSchema = pathSchema + @"\" + ObterArquivoSchema(servicoNFe, versaoServico, loteNfe);
// Define o tipo de validação
var cfg = new XmlReaderSettings {
ValidationType = ValidationType.Schema
};
// Carrega o arquivo de esquema
var schemas = new XmlSchemaSet();
cfg.Schemas = schemas;
// Quando carregar o eschema, especificar o namespace que ele valida
// e a localização do arquivo
schemas.Add(null, arquivoSchema);
// Especifica o tratamento de evento para os erros de validacao
cfg.ValidationEventHandler += ValidationEventHandler;
// cria um leitor para validação
var validator = XmlReader.Create(new StringReader(stringXml), cfg);
try
{
// Faz a leitura de todos os dados XML
while (validator.Read())
{
}
}
catch (XmlException err)
{
// Um erro ocorre se o documento XML inclui caracteres ilegais
// ou tags que não estão aninhadas corretamente
throw new Exception("Ocorreu o seguinte erro durante a validação XML:" + "\n" + err.Message);
}
catch (Exception ex)
{
throw new Exception("Ocorreu o seguinte erro durante a validação XML:" + "\n" + ex.Message);
}
finally
{
validator.Close();
}
}
/// <summary>
/// Inicializa objeto
/// </summary>
/// <param name="emissorServicoConfig">Configuração do Emissor</param>
/// <param name="certificado">Certificado Digital</param>
/// <param name="documento">Chave ou Xml Nfe bem formado</param>
/// <param name="doc">Tipo de documento a ser pesquisado</param>
/// <param name="versao">Versao do Serviço</param>
/// <param name="modelo"></param>
protected ServConsProtTemplate(EmissorServicoConfig emissorServicoConfig, X509Certificate2 certificado, string documento,
DocumentoProtocolo doc, VersaoServico versao, ModeloDocumento modelo = ModeloDocumento.NFe)
{
if (certificado == null)
{
throw new ArgumentNullException(nameof(certificado));
}
_emisorEmissorServicoConfig = emissorServicoConfig ?? throw new ArgumentNullException(nameof(emissorServicoConfig));
_servicoBase = new ServHttpSoapBase(emissorServicoConfig, certificado, NomeServico);
_chaveNfe = documento ?? throw new ArgumentNullException(nameof(documento));
_xmlNfe = documento;
_documento = doc;
_versao = versao;
_modelo = modelo;
}
public static string VersaoServicoParaString(VersaoServico versao)
{
switch (versao)
{
case VersaoServico.ve100:
return("1.00");
case VersaoServico.ve200:
return("2.00");
case VersaoServico.ve310:
return("3.10");
}
return(null);
}
public static void Valida(ServicoNFe servicoNFe, VersaoServico versaoServico, string stringXml, bool loteNfe = true, ConfiguracaoServico cfgServico = null)
{
var pathSchema = String.Empty;
if (cfgServico == null || (cfgServico != null && string.IsNullOrWhiteSpace(cfgServico.DiretorioSchemas)))
{
pathSchema = ConfiguracaoServico.Instancia.DiretorioSchemas;
}
else
{
pathSchema = cfgServico.DiretorioSchemas;
}
Valida(servicoNFe, versaoServico, stringXml, loteNfe, pathSchema);
}
public static IServidorSefaz GetServidor(Estado estado, VersaoServico versaoLayout)
{
var compativel = Servidores310.FirstOrDefault(s => s.EstadoReferente == estado);
if (versaoLayout == VersaoServico.ve400)
{
compativel = Servidores400.FirstOrDefault(s => s.EstadoReferente == estado);
}
if (compativel == null)
{
throw new InvalidOperationException("Estado não homologado pelo sistema para utilização da SEFAZ");
}
return((IServidorSefaz)compativel);
}
private void GeranNfe(VersaoServico versaoServico, ModeloDocumento modelo)
{
try
{
#region Gerar NFe
var numero = Funcoes.InpuBox("Criar e Enviar NFe", "Número da Nota:");
if (string.IsNullOrEmpty(numero))
{
throw new Exception("O Número deve ser informado!");
}
_nfe = GetNf(Convert.ToInt32(numero), modelo, versaoServico);
_nfe.Assina();
//Descomente a linha abaixo se a SEFAZ de sua UF já habilitou a NT2015.002
_nfe.infNFeSupl = new infNFeSupl()
{
qrCode = EnderecadorDanfeNfce.ObterUrlQrCode(_nfe, _configuracoes.ConfiguracaoDanfeNfce)
};
_nfe.Valida();
#endregion
ExibeNfe();
var dlg = new SaveFileDialog
{
FileName = _nfe.infNFe.Id.Substring(3),
DefaultExt = ".xml",
Filter = "Arquivo XML (.xml)|*.xml"
};
var result = dlg.ShowDialog();
if (result != true)
{
return;
}
var arquivoXml = dlg.FileName;
_nfe.SalvarArquivoXml(arquivoXml);
}
catch (Exception ex)
{
if (!string.IsNullOrEmpty(ex.Message))
{
Funcoes.Mensagem(ex.Message, "Erro", MessageBoxButton.OK);
}
}
}
protected virtual total GetTotal(VersaoServico versao)
{
var icmsTot = new ICMSTot {
vProd = 1, vNF = Decimal.Parse("0,90"), vDesc = Decimal.Parse("0,10"), vTotTrib = Decimal.Parse("0,17")
};
if (versao == VersaoServico.ve310)
{
icmsTot.vICMSDeson = 0;
}
var t = new total {
ICMSTot = icmsTot
};
return(t);
}
public static string VersaoServicoParaString(ServicoNFe servicoNFe, VersaoServico? versaoServico)
{
switch (versaoServico)
{
case VersaoServico.ve100:
return "1.00";
case VersaoServico.ve200:
switch (servicoNFe)
{
case ServicoNFe.NfeConsultaProtocolo:
return "2.01";
}
return "2.00";
case VersaoServico.ve310:
return "3.10";
}
return "";
}
public static string VersaoServicoParaString(this VersaoServico versao)
{
switch (versao)
{
case VersaoServico.Versao100:
return("1.00");
case VersaoServico.Versao200:
return("2.00");
case VersaoServico.Versao310:
return("3.10");
case VersaoServico.Versao400:
return("4.00");
}
return(null);
}
private void AtualizaVersoes(VersaoServico versaoLayout)
{
var servidorSefaz = ServidorSefazFactory.GetServidor(cUF, versaoLayout);
VersaoRecepcaoEventoCceCancelamento = servidorSefaz.EventoCceCancelamento;
VersaoRecepcaoEventoEpec = servidorSefaz.VersaoRecepcaoEventoEpec;
VersaoRecepcaoEventoManifestacaoDestinatario = servidorSefaz.ManifestacaoDestinatario;
VersaoNfeRecepcao = servidorSefaz.NfeRecepcao;
VersaoNfeRetRecepcao = servidorSefaz.NfeRetornoRecepcao;
VersaoNfeConsultaCadastro = servidorSefaz.NfeConsultaCadastro;
VersaoNfeInutilizacao = servidorSefaz.NfeInutilizacao;
VersaoNfeConsultaProtocolo = servidorSefaz.NfeConsultaProtocolo;
VersaoNfeStatusServico = servidorSefaz.NfeStatusServico;
VersaoNFeAutorizacao = servidorSefaz.NfeAutorizacao;
VersaoNFeRetAutorizacao = servidorSefaz.NfeRetornoAutorizacao;
VersaoNFeDistribuicaoDFe = servidorSefaz.NFeDistribuicaoDFe;
VersaoNfeConsultaDest = servidorSefaz.NfeConsultaDest;
VersaoNfceAministracaoCSC = servidorSefaz.VersaoNfceAministracaoCSC;
}
protected virtual dest GetDestinatario(VersaoServico versao)
{
var dest = new dest(versao)
{
CNPJ = "99999999000191",
//CPF = "99999999999",
xNome = "NF-E EMITIDA EM AMBIENTE DE HOMOLOGACAO - SEM VALOR FISCAL",
enderDest = GetEnderecoDestinatario()
};
//if (versao == VersaoServico.ve200)
// dest.IE = "ISENTO";
if (versao != VersaoServico.ve310)
{
return(dest);
}
dest.indIEDest = indIEDest.NaoContribuinte; //NFCe: Tem que ser não contribuinte V3.00 Somente
dest.email = "*****@*****.**"; //V3.00 Somente
return(dest);
}
/// <summary>
/// A versão do serviço é obrigatória por conta do tratamento que será feito na propriedade IE
/// </summary>
/// <param name="versao"></param>
public dest(VersaoServico versao)
{
_versao = versao;
IE = "";
}
public static void Valida(ServicoNFe servicoNFe, TipoRecepcaoEvento tipoRecepcaoEvento, VersaoServico versaoServico, string stringXml, bool loteNfe = true)
{
var pathSchema = ConfiguracaoServico.Instancia.DiretorioSchemas;
if (!Directory.Exists(pathSchema))
throw new Exception("Diretório de Schemas não encontrado: \n" + pathSchema);
var arquivoSchema = pathSchema + @"\" + ObterArquivoSchema(servicoNFe, tipoRecepcaoEvento, versaoServico, loteNfe);
// Define o tipo de validação
var cfg = new XmlReaderSettings {ValidationType = ValidationType.Schema};
// Carrega o arquivo de esquema
var schemas = new XmlSchemaSet();
cfg.Schemas = schemas;
// Quando carregar o eschema, especificar o namespace que ele valida
// e a localização do arquivo
schemas.Add(null, arquivoSchema);
// Especifica o tratamento de evento para os erros de validacao
cfg.ValidationEventHandler += ValidationEventHandler;
// cria um leitor para validação
var validator = XmlReader.Create(new StringReader(stringXml), cfg);
try
{
// Faz a leitura de todos os dados XML
while (validator.Read())
{
}
}
catch (XmlException err)
{
// Um erro ocorre se o documento XML inclui caracteres ilegais
// ou tags que não estão aninhadas corretamente
throw new Exception("Ocorreu o seguinte erro durante a validação XML:" + "\n" + err.Message);
}
finally
{
validator.Close();
}
}
