public IdentificacaoNFe(CodigoUfIbge uf, DateTime dataHoraEmissao, string cnpjEmissor, Modelo modelo, int serie,
string numeroNFe, TipoEmissao tipoEmissao, Ambiente ambiente, Emissor emitente,
string naturezaOperacao,
FinalidadeEmissao finalidade, bool isImpressaoBobina, PresencaComprador indicadorPresenca,
string documentoDanfe)
{
_cnpjEmissor = cnpjEmissor;
UF = uf;
DataHoraEmissao = dataHoraEmissao;
Modelo = modelo;
Serie = serie;
Numero = numeroNFe;
TipoEmissao = tipoEmissao;
Ambiente = ambiente;
Chave = CalcularChaveSemDV();
DigitoVerificador = CalcularDV(Chave);
Chave += DigitoVerificador;
CodigoMunicipio = emitente.Endereco.CodigoMunicipio;
NaturezaOperacao = naturezaOperacao;
FinalidadeEmissao = finalidade;
TipoOperacao = TipoOperacao.Saida;
OperacaoDestino = OperacaoDestino.Interna; //não suporta interestadual ainda
FormatoImpressao = isImpressaoBobina ? FormatoImpressao.Nfce : FormatoImpressao.Retrato;
FinalidadeConsumidor = documentoDanfe.Contains("CPF") || Modelo == Modelo.Modelo65
? FinalidadeConsumidor.ConsumidorFinal
: FinalidadeConsumidor.Normal;
PresencaComprador = indicadorPresenca;
ProcessoEmissao = ProcessoEmissao.AplicativoContribuinte;
VersaoAplicativo = "0.0.0.1";
}
public void ValidarInformacaoContingencia(XmlDocument conteudoXML)
{
string tipoServico = conteudoXML.DocumentElement.Name;
if (!string.IsNullOrEmpty(tipoServico))
{
if (tipoServico.Equals("NFe") || tipoServico.Equals("CTe"))
{
string tipoEmissao = conteudoXML.GetElementsByTagName("tpEmis")[0]?.InnerText;
if (!string.IsNullOrEmpty(tipoEmissao))
{
TipoEmissao tpEmissao = (TipoEmissao)Convert.ToInt32(tipoEmissao);
switch (tpEmissao)
{
case TipoEmissao.teFS:
case TipoEmissao.teEPEC:
case TipoEmissao.teFSDA:
case TipoEmissao.teOffLine:
string dhCont = conteudoXML.GetElementsByTagName("dhCont")[0]?.InnerText;
string xJust = conteudoXML.GetElementsByTagName("xJust")[0]?.InnerText;
if (string.IsNullOrEmpty(dhCont) || string.IsNullOrEmpty(xJust))
{
throw new Exception("XML em contingência e não foi informado a data, hora e justificativa da entrada em contingência, tags <dhCont> e <xJust>.");
}
break;
}
}
}
}
}
public INotaFiscalEletronica(TipoEmissao _tipoServidor, cwkAmbiente _ambiente, TipoDoCertificado _tipoCertificado, string _diretorioPadrao)
{
CwkAmbiente = _ambiente;
SetDiretorioPadrao(_diretorioPadrao);
SetSpdNFeX(_tipoServidor, _tipoCertificado);
_configuracoes = new ConfiguracaoApp();
}
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;
}
public async Task <Core.NotasFiscais.NotaFiscal> EnviarNota(NotaFiscalModel notaFiscalModel, Modelo modelo)
{
notaFiscalModel.ValidateModel();
if (notaFiscalModel.HasErrors)
{
throw new ArgumentException("Nota fiscal contém erros de validação não resolvidos.");
}
if (notaFiscalModel.Pagamentos[0].FormaPagamento != "Sem Pagamento" &&
notaFiscalModel.Produtos.Sum(c => c.QtdeProduto * c.ValorUnitario) !=
notaFiscalModel.Pagamentos.Sum(p => p.QtdeParcelas * p.ValorParcela))
{
await _dialogService.ShowError("Valor total da nota não corresponde ao valor de pagamento.",
"Erro!", "Ok", null);
throw new ArgumentException("Valor total da nota não corresponde ao valor de pagamento.");
}
Core.NotasFiscais.NotaFiscal notaFiscal = null;
var config = _configuracaoService.GetConfiguracao();
var ambiente = config.IsProducao ? Ambiente.Producao : Ambiente.Homologacao;
await Task.Run(() =>
{
var modeloNota = modelo;
const TipoEmissao tipoEmissao = TipoEmissao.Normal; //verificar status do serviço e etc
var destinatario = GetDestinatario(notaFiscalModel, ambiente, modelo);
var documentoDanfe =
destinatario != null ? destinatario.DocumentoDanfe : "CPF"; //Encapsular isso aqui
var emitente = _emissorService.GetEmissor();
var codigoUF = (CodigoUfIbge)Enum.Parse(typeof(CodigoUfIbge), emitente.Endereco.UF);
var identificacao = GetIdentificacao(notaFiscalModel, codigoUF, DateTime.Now, emitente, modeloNota,
Convert.ToInt32(notaFiscalModel.Serie), notaFiscalModel.Numero, tipoEmissao, ambiente, documentoDanfe);
var produtos = GetProdutos(notaFiscalModel, config);
var pagamentos = GetPagamentos(notaFiscalModel);
var totalNFe = GetTotalNFe(notaFiscalModel);
var infoAdicional = new InfoAdicional(produtos);
var transporte = GetTransporte(notaFiscalModel, modelo);
notaFiscal = new Core.NotasFiscais.NotaFiscal(emitente, destinatario, identificacao, transporte,
totalNFe, infoAdicional, produtos, pagamentos);
var cscId = ambiente == Ambiente.Homologacao ? config.CscIdHom : config.CscId;
var csc = ambiente == Ambiente.Homologacao ? config.CscHom : config.Csc;
_enviaNotaFiscalService.EnviarNotaFiscal(notaFiscal, cscId, csc);
});
NotaEnviadaEvent(notaFiscal);
return(notaFiscal);
}
/// <summary>
/// Identificação para NFe v4.0
/// </summary>
/// <param name="config"></param>
/// <param name="cNf"></param>
/// <param name="natOp"></param>
/// <param name="indPag"></param>
/// <param name="mod"></param>
/// <param name="serie"></param>
/// <param name="nNf"></param>
/// <param name="dEmi"></param>
/// <param name="dSaiEnt"></param>
/// <param name="dhEmi"></param>
/// <param name="dhSaiEnt"></param>
/// <param name="tpNf"></param>
/// <param name="idDest"></param>
/// <param name="tpImp"></param>
/// <param name="tpEmis"></param>
/// <param name="finNFe"></param>
/// <param name="indFinal"></param>
/// <param name="indPres"></param>
/// <param name="versaoProcesso"></param>
public IdentificacaoNFe40(Configurar config,
string cNf, string natOp,
ModeloDocumento mod, int serie, long nNf, DateTime dEmi,
DateTime dSaiEnt, DateTimeOffset dhEmi, DateTimeOffset dhSaiEnt,
TipoNFe tpNf, DestinoOperacao idDest, TipoImpressao tpImp,
TipoEmissao tpEmis, FinalidadeNFe finNFe, ConsumidorFinal indFinal,
PresencaComprador indPres, string versaoProcesso, DateTime?dhCont = null, string xJust = "")
{
var ide = new ide
{
cUF = config.EmissorConfig.Estado,
cNF = cNf,
natOp = natOp,
mod = mod,
serie = serie,
nNF = nNf,
dEmi = dEmi,
dSaiEnt = dSaiEnt,
dhEmi = dhEmi,
dhSaiEnt = dhSaiEnt,
tpNF = tpNf,
idDest = idDest,
cMunFG = config.EmissorConfig.Emitente.enderEmit.cMun,
tpImp = tpImp,
tpEmis = tpEmis,
tpAmb = config.EmissorConfig.Ambiente,
finNFe = finNFe,
indFinal = indFinal,
indPres = indPres,
verProc = versaoProcesso
};
if (dhCont != null)
{
ide.dhCont = dhCont.Value;
}
if (xJust != null)
{
ide.xJust = xJust;
}
SetIde(ide);
}
public static IspdNFeDPECX Build(TipoEmissao _tipoServidor, cwkAmbiente _ambiente, TipoDoCertificado _tipoCertificado, string diretorioPadrao)
{
TipoCertificado tipo;
switch (_tipoCertificado)
{
case TipoDoCertificado.ckFile: tipo = TipoCertificado.ckFile; break;
case TipoDoCertificado.ckSmartCard: tipo = TipoCertificado.ckSmartCard; break;
case TipoDoCertificado.ckMemory: tipo = TipoCertificado.ckMemory; break;
case TipoDoCertificado.ckLocalMachine: tipo = TipoCertificado.ckLocalMashine; break;
case TipoDoCertificado.ckActiveDirectory: tipo = TipoCertificado.ckActiveDirectory; break;
default:
tipo = TipoCertificado.ckFile;
break;
}
try
{
IspdNFeDPECX spdNFeDPECX = BuildNormal(_ambiente, diretorioPadrao);
spdNFeDPECX.TipoCertificado = tipo;
return(spdNFeDPECX);
}
catch (Exception)
{
return(null);
}
// Código legado -- retirada dos métodos relacionados à SCAN, em favor do SVCAN/SVCRS (Ticket #2875)
//switch (_tipoServidor)
//{
// case TipoEmissao.Normal: spdNFeX = BuildNormal(_ambiente, diretorioPadrao); spdNFeX.TipoCertificado = tipo; return spdNFeX;
// case TipoEmissao.SCAN: spdNFeX = BuildSCAN(_ambiente); spdNFeX.TipoCertificado = tipo; return spdNFeX;
//}
}
public static string TipoEmissaoParaString(TipoEmissao tipoEmissao)
{
var s = Enum.GetName(typeof(TipoEmissao), tipoEmissao);
return(s != null?s.Substring(2) : "");
}
internal ChaveDFe(CodigoUF ufEmitente, DateTime dataEmissao, string cnpjEmitente, int modelo, int serie, long numero, TipoEmissao tipoEmissao, int codigoNumerico)
{
var chave = new StringBuilder();
chave.Append(ufEmitente.GetDFeValue())
.Append(dataEmissao.ToString("yyMM"))
.Append(cnpjEmitente)
.Append(modelo.ToString("D2"))
.Append(serie.ToString("D3"))
.Append(numero.ToString("D9"))
.Append(tipoEmissao.GetDFeValue())
.Append(codigoNumerico.ToString("D8"));
var digitoVerificador = DigitoVerificador.Obter(chave.ToString());
chave.Append(digitoVerificador);
Chave = chave.ToString();
Digito = digitoVerificador;
}
private void SetSpdNFeX(TipoEmissao _tipoServidor, TipoDoCertificado _tipoCertificado)
{
SpdNFeX = ((spdNFeX)FactoryIspdNFeX.Build(_tipoServidor, CwkAmbiente, _tipoCertificado, DiretorioPadrao));
}
private void buttonPesquisa_Click(object sender, EventArgs e)
{
this.Refresh();
txtMensagem.Clear();
metroGridSituacao.Rows.Clear();
bool todasEmpresas = cbEmpresa.SelectedValue.Equals("Todos");
try
{
TipoEmissao tpEmis = (TipoEmissao)this.cbEmissao.SelectedValue;
int amb = (int)cbAmbiente.SelectedValue;
string versao = this.cbVersao.SelectedItem.ToString();
TipoAplicativo servico = TipoAplicativo.Nulo;
int cUF = 0;
if (!todasEmpresas)
{
servico = (TipoAplicativo)cbServico.SelectedValue;
cUF = Functions.UFParaCodigo(this.comboUf.SelectedValue.ToString());
switch (servico)
{
case TipoAplicativo.Cte:
if (tpEmis == TipoEmissao.teSVCAN) // this.cbEmissao.SelectedIndex == 4)
{
throw new Exception("CT-e não dispõe do tipo de contingência SVCAN.");
}
break;
case TipoAplicativo.Nfe:
if (tpEmis == TipoEmissao.teSVCSP) // this.cbEmissao.SelectedIndex == 3)
{
throw new Exception("NF-e não dispõe do tipo de contingência SVCSP.");
}
break;
case TipoAplicativo.MDFe:
if (tpEmis != TipoEmissao.teNormal)
{
throw new Exception("MDF-e só dispõe do tipo de emissão Normal.");
}
break;
case TipoAplicativo.NFCe:
if (tpEmis != TipoEmissao.teNormal)
{
throw new Exception("NFC-e só dispõe do tipo de emissão Normal.");
}
break;
}
}
Formularios.Wait.Show("Consulta a situação do serviço...");
List <ConsultaRealizada> consultasRealizadas = new List <ConsultaRealizada>();
if (todasEmpresas)
{
tpEmis = TipoEmissao.teNormal;
for (int i = 0; i < Empresas.Configuracoes.Count; i++)
{
int emp = Empresas.FindConfEmpresaIndex(Empresas.Configuracoes[i].CNPJ, Empresas.Configuracoes[i].Servico);
cUF = Empresas.Configuracoes[emp].UnidadeFederativaCodigo;
switch (Empresas.Configuracoes[emp].Servico)
{
case TipoAplicativo.Todos:
GerarConsulta(emp, TipoAplicativo.Nfe, (int)tpEmis, cUF, amb, "4.00", consultasRealizadas);
GerarConsulta(emp, TipoAplicativo.NFCe, (int)tpEmis, cUF, amb, "4.00", consultasRealizadas);
GerarConsulta(emp, TipoAplicativo.MDFe, (int)tpEmis, cUF, amb, "3.00", consultasRealizadas);
GerarConsulta(emp, TipoAplicativo.Cte, (int)tpEmis, cUF, amb, "3.00", consultasRealizadas);
break;
case TipoAplicativo.Nfe:
GerarConsulta(emp, TipoAplicativo.Nfe, (int)tpEmis, cUF, amb, "4.00", consultasRealizadas);
break;
case TipoAplicativo.Cte:
GerarConsulta(emp, TipoAplicativo.Cte, (int)tpEmis, cUF, amb, "3.00", consultasRealizadas);
break;
case TipoAplicativo.MDFe:
GerarConsulta(emp, TipoAplicativo.MDFe, (int)tpEmis, cUF, amb, "3.00", consultasRealizadas);
break;
case TipoAplicativo.NFCe:
GerarConsulta(emp, TipoAplicativo.NFCe, (int)tpEmis, cUF, amb, "4.00", consultasRealizadas);
break;
}
}
}
else
{
GerarConsulta(Emp, servico, (int)tpEmis, cUF, amb, versao, consultasRealizadas);
}
//Demonstrar o status do serviço
for (int i = 0; i < consultasRealizadas.Count; i++)
{
string nomeEmpresa = consultasRealizadas[i].Empresa.Nome;
string tipoServico = consultasRealizadas[i].Servico.ToString();
string uf = Functions.CodigoParaUF(consultasRealizadas[i].Empresa.UnidadeFederativaCodigo);
string result = VerStatusServico(consultasRealizadas[i].ArquivoRetorno, consultasRealizadas[i].Emp);
metroGridSituacao.Rows.Add(new object[] { nomeEmpresa, uf, tipoServico, result });
}
}
catch (Exception ex)
{
Formularios.Wait.Close();
txtMensagem.Text = ex.Message;
}
}
public static INotaFiscalEletronica NotaFiscalEletronicaFactory(VersaoXML _versaoXml, TipoEmissao _tipoServidor, cwkAmbiente _ambiente, TipoDoCertificado _tipoCertificado
, string diretorioPadrao, Int16 indFinal, IndPres indPres, bool bDevolucao, int modeloDocumento, int componenteDfe, ConfiguracaoManager configManager = null)
{
INotaFiscalEletronica retorno;
if (modeloDocumento == 55)
{
switch (_versaoXml)
{
case VersaoXML.v3:
retorno = new NotaFiscalEletronica30(_tipoServidor, _ambiente, _tipoCertificado, diretorioPadrao);
break;
case VersaoXML.v4:
retorno = new NotaFiscalEletronica40(_tipoServidor, _ambiente, _tipoCertificado, diretorioPadrao);
break;
case VersaoXML.v5a:
retorno = new NotaFiscalEletronica50a(_tipoServidor, _ambiente, _tipoCertificado, diretorioPadrao, indFinal, indPres, bDevolucao);
break;
case VersaoXML.v6:
if (componenteDfe == 0) //0 = Tecnospeed / 1 = Zeus Automação
{
retorno = new NotaFiscalEletronica60(_tipoServidor, _ambiente, _tipoCertificado, diretorioPadrao, indFinal, indPres, bDevolucao);
}
else
{
retorno = new NotaFiscalEletronicaZeus60(_tipoServidor, _ambiente, _tipoCertificado, diretorioPadrao, indFinal, indPres, bDevolucao);
}
break;
default:
throw new Exception("Versão do XML " + _versaoXml + " não implementado para a NF-e");
//return null;
}
}
else
{
switch (_versaoXml)
{
case VersaoXML.v5a:
retorno = new NotaFiscalEletronicaConsumidor50a(_tipoServidor, _ambiente, _tipoCertificado, diretorioPadrao, indFinal, indPres, bDevolucao, configManager);
break;
case VersaoXML.v6:
if (componenteDfe == 0) //0 = Tecnospeed / 1 = Zeus Automação
{
retorno = new NotaFiscalEletronicaConsumidor60(_tipoServidor, _ambiente, _tipoCertificado, diretorioPadrao, indFinal, indPres, bDevolucao, configManager);
}
else
{
retorno = new NotaFiscalEletronicaConsumidorZeus60(_tipoServidor, _ambiente, _tipoCertificado, diretorioPadrao, indFinal, indPres, bDevolucao);
}
break;
default:
throw new Exception("Versão do XML " + _versaoXml + "não implementado para a NFC-e");
}
}
retorno.FormaEmissao = _tipoServidor;
retorno.TipoDoCertificado = _tipoCertificado;
return(retorno);
}
private void buttonStatusServidor_Click(object sender, EventArgs e)
{
this.textResultado.Text = "";
this.Refresh();
TipoEmissao tpEmis = (TipoEmissao)Enum.Parse(typeof(TipoEmissao), Enum.GetName(typeof(TipoEmissao), ((ComboElem)(new System.Collections.ArrayList(arrTpEmis))[cbEmissao.SelectedIndex]).Codigo));
TipoAplicativo servico = (TipoAplicativo)cbServico.SelectedIndex;
if (servico == TipoAplicativo.Cte)
{
if (tpEmis == TipoEmissao.teSVCAN)
{
MessageBox.Show("CT-e não dispõe do tipo de contingência SVCAN.", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
}
else if (servico == TipoAplicativo.Nfe)
{
if (tpEmis == TipoEmissao.teSVCSP)
{
MessageBox.Show("NF-e não dispõe do tipo de contingência SCVSP.", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
}
else if (servico == TipoAplicativo.MDFe)
{
if (tpEmis != TipoEmissao.teNormal)
{
MessageBox.Show("MDF-e só dispõe do tipo de emissão Normal.", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
}
else if (servico == TipoAplicativo.NFCe)
{
if (tpEmis != TipoEmissao.teNormal)
{
MessageBox.Show("NFC-e só dispõe do tipo de emissão Normal.", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
}
this.toolStripStatusLabel1.Text = _wait;
this.Refresh();
this.Cursor = Cursors.WaitCursor;
try
{
GerarXML oGerar = new GerarXML(Emp);
int cUF = ((ComboElem)(new System.Collections.ArrayList(arrUF))[comboUf.SelectedIndex]).Codigo;
int amb = ((ComboElem)(new System.Collections.ArrayList(arrAmb))[cbAmbiente.SelectedIndex]).Codigo;
string XmlNfeDadosMsg = Empresas.Configuracoes[Emp].PastaXmlEnvio + "\\" + oGerar.StatusServico(servico, (int)tpEmis, cUF, amb, this.cbVersao.SelectedItem.ToString());
//Demonstrar o status do serviço
this.textResultado.Text = VerStatusServico(XmlNfeDadosMsg);
}
catch (Exception ex)
{
this.textResultado.Text = ex.Message;
}
finally
{
this.Cursor = Cursors.Default;
this.toolStripStatusLabel1.Text = "";
}
}
private static IdentificacaoNFe GetIdentificacao(CodigoUfIbge codigoUF, DateTime now, Emissor emitente, Modelo modeloNota,
int serie, string numeroNFe, TipoEmissao tipoEmissao, Ambiente ambiente, string documentoDanfe)
{
var identificacao = new IdentificacaoNFe(codigoUF, now, emitente.CNPJ, modeloNota, serie, numeroNFe, tipoEmissao, ambiente, emitente,
"Venda", FinalidadeEmissao.Normal, true, PresencaComprador.Presencial, documentoDanfe);
return(identificacao);
}
public static INotaFiscalEletronica NotaFiscalEletronicaFactory(VersaoXML _versaoXml, TipoEmissao _tipoServidor, cwkAmbiente _ambiente, TipoDoCertificado _tipoCertificado
, string diretorioPadrao, Int16 indFinal, IndPres indPres, bool bDevolucao, int modeloDocumento = 55, int componenteDfe = 1)
{
return(NotaFiscalEletronicaFactory(_versaoXml, _tipoServidor, _ambiente, _tipoCertificado, diretorioPadrao, indFinal, indPres, bDevolucao, modeloDocumento, componenteDfe, new ConfiguracaoManager()));
}
private void buttonPesquisa_Click(object sender, EventArgs e)
{
this.textResultado.Clear();
this.Refresh();
try
{
TipoAplicativo servico = (TipoAplicativo)cbServico.SelectedValue;
TipoEmissao tpEmis = (TipoEmissao)this.cbEmissao.SelectedValue;
switch (servico)
{
case TipoAplicativo.Cte:
if (tpEmis == TipoEmissao.teSVCAN) // this.cbEmissao.SelectedIndex == 4)
{
throw new Exception("CT-e não dispõe do tipo de contingência SVCAN.");
}
break;
case TipoAplicativo.Nfe:
if (tpEmis == TipoEmissao.teSVCSP) // this.cbEmissao.SelectedIndex == 3)
{
throw new Exception("NF-e não dispõe do tipo de contingência SCVSP.");
}
break;
case TipoAplicativo.MDFe:
if (tpEmis != TipoEmissao.teNormal)
{
throw new Exception("MDF-e só dispõe do tipo de emissão Normal.");
}
break;
case TipoAplicativo.NFCe:
if (tpEmis != TipoEmissao.teNormal)
{
throw new Exception("NFC-e só dispõe do tipo de emissão Normal.");
}
break;
}
this.textResultado.Text = "Consultando o servidor. Aguarde....";
this.textResultado.Update();
GerarXML oGerar = new GerarXML(Emp);
int cUF = NFe.Components.Functions.UFParaCodigo(this.comboUf.SelectedValue.ToString());
int amb = (int)cbAmbiente.SelectedValue;
string versao = this.cbVersao.SelectedItem.ToString();
NFe.UI.Formularios.Wait.Show("Consulta a situação do serviço...");
string XmlNfeDadosMsg = Empresas.Configuracoes[Emp].PastaXmlEnvio + "\\" +
oGerar.StatusServico(servico, (int)tpEmis, cUF, amb, versao);
//Demonstrar o status do serviço
this.textResultado.Text = VerStatusServico(XmlNfeDadosMsg);
}
catch (Exception ex)
{
NFe.UI.Formularios.Wait.Close();
this.textResultado.Text = ex.Message;
}
}
public static string GerarQrCodeNFe(string chave, Destinatario destinatario, string digestValue, Ambiente ambiente, DateTime dhEmissao,
string valorNF, string valorICMS, string cIdToken, string csc, TipoEmissao tipoEmissão)
{
if (tipoEmissão == TipoEmissao.Normal)
{
return(GerarQrCodeNFeEmissãoOnline(chave, ambiente, cIdToken, csc));
}
else
{
return(GerarQrCodeNFeEmissãoOffline(chave, digestValue, ambiente, dhEmissao.Day, valorNF, cIdToken, csc));
}
}
private ConfiguracaoServico ConfiguraServico(Estado uf, ModeloDocumento mod,
NFe.Classes.Informacoes.Identificacao.Tipos.TipoAmbiente ta, TipoEmissao te, int timeOut,
SecurityProtocolType spt, ConfiguracaoCertificado certificate)
{
var cfgServico = NFe.Utils.ConfiguracaoServico.Instancia;
cfgServico.ModeloDocumento = mod;
cfgServico.tpAmb = ta;
cfgServico.tpEmis = te;
cfgServico.TimeOut = timeOut;
cfgServico.ProtocoloDeSeguranca = spt;
cfgServico.Certificado = certificate;
cfgServico.VersaoNFeDistribuicaoDFe = VersaoServico.ve100;
cfgServico.VersaoRecepcaoEventoManifestacaoDestinatario = VersaoServico.ve100;
cfgServico.VersaoNfeDownloadNF = VersaoServico.ve310;
cfgServico.cUF = uf;
cfgServico.DiretorioSchemas = Constants.SchemasPath;
cfgServico.DiretorioSalvarXml = Constants.DfeAppPath;
_configServico = cfgServico;
return(_configServico);
}
/// <summary>
/// Gera a chave do documento fiscal
/// </summary>
/// <param name="ufEmitente">UF do emitente do DF-e</param>
/// <param name="dataEmissao">Data de emissão do DF-e</param>
/// <param name="cnpjEmitente">CNPJ do emitente do DF-e</param>
/// <param name="modelo">Modelo do DF-e</param>
/// <param name="serie">Série do DF-e</param>
/// <param name="numero">Numero do DF-e</param>
/// <param name="tipoEmissao">
/// Tipo de emissão do DF-e. Informar inteiro conforme consta no manual de orientação do contribuinte para o DF-e
/// </param>
/// <param name="codigoNumerico">Código numérico que compõe a Chave de Acesso. Número gerado pelo emitente para cada DF-e</param>
/// <returns>Retorna a chave DFe</returns>
public static ChaveDFe Gerar(CodigoUF ufEmitente, DateTime dataEmissao, string cnpjEmitente, int modelo, int serie, long numero, TipoEmissao tipoEmissao, int codigoNumerico)
{
return(new ChaveDFe(ufEmitente, dataEmissao, cnpjEmitente, modelo, serie, numero, tipoEmissao, codigoNumerico));
}
public NotaFiscalEletronica30(TipoEmissao _tipoServidor, cwkAmbiente _ambiente, TipoDoCertificado _tipoCertificado, string _diretorioPadrao)
: base(_tipoServidor, _ambiente, _tipoCertificado, _diretorioPadrao)
{
}
public static string TipoEmissaoParaString(TipoEmissao tipoEmissao)
{
var s = Enum.GetName(typeof (TipoEmissao), tipoEmissao);
return s != null ? s.Substring(2) : "";
}
private static IdentificacaoNFe GetIdentificacao(NotaFiscalModel NotaFiscal, CodigoUfIbge codigoUF, DateTime now,
Emissor emitente, Modelo modeloNota,
int serie, string numeroNFe, TipoEmissao tipoEmissao, Ambiente ambiente, string documentoDanfe)
{
var finalidadeEmissao = (FinalidadeEmissao)Enum.Parse(typeof(FinalidadeEmissao), Acentuacao.RemoverAcentuacao(NotaFiscal.Finalidade));
var identificacao = new IdentificacaoNFe(codigoUF, now, emitente.CNPJ, modeloNota, serie, numeroNFe,
tipoEmissao, ambiente, emitente,
NotaFiscal.NaturezaOperacao, finalidadeEmissao, NotaFiscal.IsImpressaoBobina,
NotaFiscal.IndicadorPresenca, documentoDanfe);
return(identificacao);
}
