public bool ExecutarConsultaStatus(ConfiguracaoEntity config, Modelo modelo)
{
var ambiente = config.IsProducao ? Ambiente.Producao : Ambiente.Homologacao;
var codigoUf = (CodigoUfIbge)Enum.Parse(typeof(CodigoUfIbge), _emissorService.GetEmissor().Endereco.UF);
X509Certificate2 certificado = null;
var certificadoEntity = _certificadoService.GetCertificado();
if (certificadoEntity == null)
{
return(false);
}
if (!string.IsNullOrWhiteSpace(certificadoEntity.Caminho))
{
certificado = _certificateManager.GetCertificateByPath(certificadoEntity.Caminho,
RijndaelManagedEncryption.DecryptRijndael(certificadoEntity.Senha));
}
else
{
certificado = _certificateManager.GetCertificateBySerialNumber(certificadoEntity.NumeroSerial, false);
}
return(NFeStatusServico.ExecutarConsultaStatus(codigoUf, ambiente, certificado, modelo));
}
public static int EnviarNotaFiscal(out NotaFiscal notaFiscal, out ConfiguracaoEntity config, Destinatario destinatario = null)
{
notaFiscal = null;
config = ConfiguracaoService.GetConfiguracao();
var ambiente = Ambiente.Homologacao;
var modeloNota = Modelo.Modelo65;
var tipoEmissao = TipoEmissao.Normal;
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 serie = config.SerieNFCeHom;
var numero = config.ProximoNumNFCeHom;
var identificacao = GetIdentificacao(codigoUF, DateTime.Now, emitente, modeloNota, Convert.ToInt32(serie), numero, tipoEmissao, ambiente, documentoDanfe);
var produtos = GetProdutos(config);
var totalNFe = GetTotalNFe();
var pagamentos = GetPagamentos();
var infoAdicional = new InfoAdicional(produtos);
var transporte = new Transporte(modeloNota, null, null);
notaFiscal = new NFe.Core.TO.NotaFiscal(emitente, destinatario, identificacao, transporte, totalNFe, infoAdicional, produtos, pagamentos);
string cscId = config.CscIdHom;
string csc = config.CscHom;
NotaFiscalService notaService = new NotaFiscalService();
return(notaService.EnviarNotaFiscalAsync(notaFiscal, cscId, csc).Result);
}
private void LoadedCmd_Execute()
{
var configuracao = _configuracaoService.GetConfiguracao();
if (configuracao == null)
{
return;
}
IsProducao = configuracao.IsProducao;
CscHom = configuracao.CscHom;
CscIdHom = configuracao.CscIdHom;
EmailContabilidadeHom = configuracao.EmailContabilidadeHom;
ProximoNumNFCeHom = configuracao.ProximoNumNFCeHom;
ProximoNumNFeHom = configuracao.ProximoNumNFeHom;
SerieNFCeHom = configuracao.SerieNFCeHom;
SerieNFeHom = configuracao.SerieNFeHom;
CscProd = configuracao.Csc;
CscIdProd = configuracao.CscId;
EmailContabilidadeProd = configuracao.EmailContabilidade;
ProximoNumNFCeProd = configuracao.ProximoNumNFCe;
ProximoNumNFeProd = configuracao.ProximoNumNFe;
SerieNFCeProd = configuracao.SerieNFCe;
SerieNFeProd = configuracao.SerieNFe;
_configuracao = configuracao;
}
public int Salvar(ConfiguracaoEntity configuracao)
{
if (configuracao.Id == 0)
{
_context.Configuracao.Add(configuracao);
}
_context.SaveChanges();
return(configuracao.Id);
}
private static List <NFe.Core.Model.Produto> GetProdutos(ConfiguracaoEntity config)
{
var produtos = new List <NFe.Core.Model.Produto>();
var ProdutoEntity = ProdutoService.GetByCodigo("0001");
var grupoImpostos = new GrupoImpostosRepository(context).GetById(ProdutoEntity.GrupoImpostosId);
var produto = new NFe.Core.Model.Produto(grupoImpostos, ProdutoEntity.Id, grupoImpostos.CFOP, ProdutoEntity.Codigo, ProdutoEntity.Descricao, ProdutoEntity.NCM,
1, ProdutoEntity.UnidadeComercial,
ProdutoEntity.ValorUnitario, 0, !config.IsProducao);
produtos.Add(produto);
return(produtos);
}
public ConfiguracaoRepositoryFake()
{
_configuracao = new ConfiguracaoEntity()
{
Id = 1,
SerieNFCe = "001",
SerieNFCeHom = "001",
SerieNFe = "001",
SerieNFeHom = "001",
ProximoNumNFCe = "1",
ProximoNumNFCeHom = "1",
ProximoNumNFe = "1",
ProximoNumNFeHom = "1",
IsProducao = false
};
}
private void LoadConfig(bool isProducao)
{
_configuracao = _configuracaoService.GetConfiguracao();
CscHom = _configuracao.CscHom;
CscIdHom = _configuracao.CscIdHom;
EmailContabilidadeHom = _configuracao.EmailContabilidadeHom;
ProximoNumNFCeHom = _configuracao.ProximoNumNFCeHom;
ProximoNumNFeHom = _configuracao.ProximoNumNFeHom;
SerieNFCeHom = _configuracao.SerieNFCeHom;
SerieNFeHom = _configuracao.SerieNFeHom;
CscProd = _configuracao.Csc;
CscIdProd = _configuracao.CscId;
EmailContabilidadeProd = _configuracao.EmailContabilidade;
ProximoNumNFCeProd = _configuracao.ProximoNumNFCe;
ProximoNumNFeProd = _configuracao.ProximoNumNFe;
SerieNFCeProd = _configuracao.SerieNFCe;
SerieNFeProd = _configuracao.SerieNFe;
}
private static void ConfigurarConfiguracao()
{
var configuracao = new ConfiguracaoEntity
{
Id = 1,
SerieNFCe = "001",
SerieNFCeHom = "001",
SerieNFe = "001",
SerieNFeHom = "001",
ProximoNumNFCe = "1",
ProximoNumNFCeHom = "1",
ProximoNumNFe = "1",
ProximoNumNFeHom = "1",
IsProducao = false
};
var configuracaoServiceMock = new Mock <IConfiguracaoService>();
configuracaoServiceMock.Setup(m => m.GetConfiguracao()).Returns(configuracao);
}
private void SalvarCmd_Execute(Window wdw)
{
ValidateModel();
if (!HasErrors)
{
ConfiguracaoEntity configuracao = null;
if (_configuracaoService.GetConfiguracao() == null)
{
configuracao = new ConfiguracaoEntity();
}
else
{
configuracao = _configuracaoService.GetConfiguracao();
}
configuracao.IsProducao = IsProducao;
configuracao.CscHom = CscHom;
configuracao.CscIdHom = CscIdHom;
configuracao.EmailContabilidadeHom = EmailContabilidadeHom;
configuracao.ProximoNumNFCeHom = ProximoNumNFCeHom;
configuracao.ProximoNumNFeHom = ProximoNumNFeHom;
configuracao.SerieNFCeHom = SerieNFCeHom;
configuracao.SerieNFeHom = SerieNFeHom;
configuracao.Csc = CscProd;
configuracao.CscId = CscIdProd;
configuracao.EmailContabilidade = EmailContabilidadeProd;
configuracao.ProximoNumNFCe = ProximoNumNFCeProd;
configuracao.ProximoNumNFe = ProximoNumNFeProd;
configuracao.SerieNFCe = SerieNFCeProd;
configuracao.SerieNFe = SerieNFeProd;
_configuracaoService.Salvar(configuracao);
_configuracao = null;
ConfiguracaoAlteradaEvent();
wdw.Close();
}
}
public void Salvar(ConfiguracaoEntity configuracao)
{
var config = _configuracaoRepository.GetConfiguracao();
if (config == null)
{
config = new ConfiguracaoEntity();
}
config.IsProducao = configuracao.IsProducao;
config.CscHom = configuracao.CscHom;
config.CscIdHom = configuracao.CscIdHom;
config.EmailContabilidadeHom = configuracao.EmailContabilidadeHom;
config.ProximoNumNFCeHom = configuracao.ProximoNumNFCeHom;
config.ProximoNumNFeHom = configuracao.ProximoNumNFeHom;
config.SerieNFCeHom = configuracao.SerieNFCeHom;
config.SerieNFeHom = configuracao.SerieNFeHom;
config.Csc = configuracao.Csc;
config.CscId = configuracao.CscId;
config.EmailContabilidade = configuracao.EmailContabilidade;
config.ProximoNumNFCe = configuracao.ProximoNumNFCe;
config.ProximoNumNFe = configuracao.ProximoNumNFe;
config.SerieNFCe = configuracao.SerieNFCe;
config.SerieNFe = configuracao.SerieNFe;
config.IsContingencia = configuracao.IsContingencia;
if (configuracao.DataHoraEntradaContingencia == new DateTime())
{
config.DataHoraEntradaContingencia = DateTime.Now;
}
else
{
config.DataHoraEntradaContingencia = configuracao.DataHoraEntradaContingencia;
}
config.JustificativaContingencia = configuracao.JustificativaContingencia;
_configuracaoRepository.Salvar(config);
}
private List <Produto> GetProdutos(NotaFiscalModel notaFiscal, ConfiguracaoEntity config)
{
var idsProdutosSelecionados = notaFiscal.Produtos.Select(p => p.ProdutoSelecionado.Id);
var produtosTo = _produtoService.GetAll().Where(p => idsProdutosSelecionados.Contains(p.Id));
var produtos = new List <Produto>();
foreach (var produtoNota in notaFiscal.Produtos)
{
var produtoEntity = produtosTo.First(c => c.Id == produtoNota.ProdutoSelecionado.Id);
var produto = new Produto(produtoEntity.GrupoImpostos, produtoEntity.Id,
produtoEntity.GrupoImpostos.CFOP, produtoEntity.Codigo, produtoEntity.Descricao, produtoEntity.NCM,
notaFiscal.Produtos.First(p => p.ProdutoSelecionado.Id == produtoEntity.Id).QtdeProduto,
produtoEntity.UnidadeComercial,
produtoNota.ValorUnitario, produtoNota.Descontos, !config.IsProducao);
produtos.Add(produto);
}
return(produtos);
}
public Task <ConfiguracaoEntity> GetConfiguracaoAsync()
{
return(Task.Run(() => { return _configuracao = _configuracaoRepository.GetConfiguracao(); }));
}
public ConfiguracaoEntity GetConfiguracao()
{
return(_configuracao = _configuracaoRepository.GetConfiguracao());
}
public ConfiguracaoService(IConfiguracaoRepository configuracaoRepository)
{
_configuracaoRepository = configuracaoRepository;
_configuracao = _configuracaoRepository.GetConfiguracao();
}
public int Salvar(ConfiguracaoEntity configuracao)
{
_configuracao = configuracao;
return(_configuracao.Id);
}
public void Excluir(ConfiguracaoEntity configuracao)
{
_context.Configuracao.Remove(configuracao);
_context.SaveChanges();
}
private async Task<List<string>> TransmitirConsultarLoteContingenciaAsync(ConfiguracaoEntity config,
List<string> notasNfCe, Modelo modelo)
{
var retornoTransmissao = TransmitirLoteNotasFiscaisContingencia(notasNfCe, modelo);
switch (retornoTransmissao.TipoMensagem)
{
case TipoMensagem.ErroValidacao:
return new List<string> { retornoTransmissao.Mensagem };
case TipoMensagem.ServicoIndisponivel:
return new List<string> { MensagemErro };
}
var tempoEspera = int.Parse(retornoTransmissao.RetEnviNFeInfRec.tMed) * 1000;
var erros = new List<string>();
Thread.Sleep(tempoEspera);
var resultadoConsulta = ConsultarReciboLoteContingencia(retornoTransmissao.RetEnviNFeInfRec.nRec, modelo);
if (resultadoConsulta == null) return new List<string> { MensagemErro };
foreach (var resultado in resultadoConsulta)
{
var nota = _notaFiscalRepository.GetNotaFiscalByChave(resultado.Chave);
if (resultado.CodigoStatus == "100")
{
nota.DataAutorizacao = DateTime.ParseExact(resultado.DataAutorizacao, "yyyy-MM-ddTHH:mm:sszzz",
CultureInfo.InvariantCulture);
nota.Protocolo = resultado.Protocolo;
nota.Status = (int)Status.ENVIADA;
var xml = await nota.LoadXmlAsync();
xml = xml.Replace("<protNFe />", resultado.Xml);
_notaFiscalRepository.Salvar(nota, xml);
}
else
{
if (resultado.Motivo.Contains("Duplicidade"))
{
X509Certificate2 certificado;
var certificadoEntity = _certificadoRepository.GetCertificado();
var emitente = _emissorService.GetEmissor();
if (!string.IsNullOrWhiteSpace(certificadoEntity.Caminho))
certificado = _certificateManager.GetCertificateByPath(certificadoEntity.Caminho,
RijndaelManagedEncryption.DecryptRijndael(certificadoEntity.Senha));
else
certificado =
_certificateManager.GetCertificateBySerialNumber(certificadoEntity.NumeroSerial, false);
var retornoConsulta = _nfeConsulta.ConsultarNotaFiscal
(
nota.Chave,
emitente.Endereco.CodigoUF,
certificado,
config.IsProducao ? Ambiente.Producao : Ambiente.Homologacao,
nota.Modelo.Equals("65") ? Modelo.Modelo65 : Modelo.Modelo55
);
if (retornoConsulta.IsEnviada)
{
var protSerialized = XmlUtil.Serialize(retornoConsulta.Protocolo, string.Empty)
.Replace("<?xml version=\"1.0\" encoding=\"utf-8\"?>", string.Empty)
.Replace("TProtNFe", "protNFe");
protSerialized = Regex.Replace(protSerialized, "<infProt (.*?)>", "<infProt>");
nota.DataAutorizacao = retornoConsulta.DhAutorizacao;
nota.Protocolo = retornoConsulta.Protocolo.infProt.nProt;
nota.Status = (int)Status.ENVIADA;
var xml = await nota.LoadXmlAsync();
xml = xml.Replace("<protNFe />", protSerialized);
_notaFiscalRepository.Salvar(nota, xml);
}
else
{
erros.Add(
$"Modelo: {nota.Modelo} Nota: {nota.Numero} Série: {nota.Serie} \nMotivo: {resultado.Motivo}"); //O que fazer com essas mensagens de erro?
}
}
else
{
erros.Add(
$"Modelo: {nota.Modelo} Nota: {nota.Numero} Série: {nota.Serie} \nMotivo: {resultado.Motivo}"); //O que fazer com essas mensagens de erro?
}
}
}
return erros;
}
public void Excluir(ConfiguracaoEntity configuracao)
{
throw new NotImplementedException();
}
private Task <NotaFiscalEntity> ConsultarNotasAsync(int idNotaFiscalDb, string codigoUf,
X509Certificate2 certificado, ConfiguracaoEntity config)
{
return(Task.Run(async() =>
{
var notaFiscalDb = _notaFiscalRepository.GetNotaFiscalById(idNotaFiscalDb, true);
var document = new XmlDocument();
var ambiente = config.IsProducao ? Ambiente.Producao : Ambiente.Homologacao;
var modelo = notaFiscalDb.Modelo.Equals("65") ? Modelo.Modelo65 : Modelo.Modelo55;
var mensagemRetorno =
_nfeConsulta.ConsultarNotaFiscal(notaFiscalDb.Chave, codigoUf, certificado, ambiente, modelo);
if (!mensagemRetorno.IsEnviada)
{
return null;
}
mensagemRetorno.Protocolo.infProt.Id = null;
var protSerialized = XmlUtil.Serialize(mensagemRetorno.Protocolo, "");
var doc = XDocument.Parse(protSerialized);
doc.Descendants().Attributes().Where(a => a.IsNamespaceDeclaration).Remove();
foreach (var element in doc.Descendants())
{
element.Name = element.Name.LocalName;
}
using (var xmlReader = doc.CreateReader())
{
document.Load(xmlReader);
}
notaFiscalDb.DataAutorizacao = mensagemRetorno.Protocolo.infProt.dhRecbto;
notaFiscalDb.Protocolo = mensagemRetorno.Protocolo.infProt.nProt;
var xml = await notaFiscalDb.LoadXmlAsync();
xml = xml.Replace("<protNFe />", document.OuterXml.Replace("TProtNFe", "protNFe"));
notaFiscalDb.Status = (int)Status.ENVIADA;
_notaFiscalRepository.Salvar(notaFiscalDb, xml);
return notaFiscalDb;
}));
}
