public static void Assinar(this inutCTe inutCTe, ConfiguracaoServico configuracaoServico = null)
{
var configServico = configuracaoServico ?? ConfiguracaoServico.Instancia;
inutCTe.Signature = AssinaturaDigital.Assina(inutCTe, inutCTe.infInut.Id,
configServico.X509Certificate2);
}
public GeradorDeNfce()
{
CfgServico = ConfiguracaoServico.Instancia;
CfgServico.tpAmb = TipoAmbiente.Homologacao;
CfgServico.tpEmis = TipoEmissao.teNormal;
CfgServico.ProtocoloDeSeguranca = ServicePointManager.SecurityProtocol;
var emitente = new emit
{
CNPJ = "31808064000147",
IE = "9079550016",
xFant = "Joao Victor Spinoza",
xNome = "Joao Victor Spinoza"
};
var configuracaoDeEmail = new ConfiguracaoEmail("*****@*****.**", "senha", "Envio de NFE", "Teset123", "smtp.dominio.com", 587, true, true);
var configuracaoDanfeNfe = new ConfiguracaoDanfeNfce(NfceDetalheVendaNormal.UmaLinha, NfceDetalheVendaContigencia.UmaLinha);
_configuracoes = new Configuracao(
GetEnderecoEmitente(),
CfgServico,
emitente,
configuracaoDeEmail,
configuracaoDanfeNfe
);
}
public ConsultaSituacaoNFeServico(ConfiguracaoServico cfgServico, IStorage storage, ITransmitirSefazCommand transmitir)
{
this.cfgServico = cfgServico;
this.storage = storage;
this.sefaz = transmitir;
this.versao = "4.00";
}
private void CredenciadoInutilizadoExcluir(List <ConfiguracaoServico> configuracoes, BancoDeDados banco)
{
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
ConfiguracaoServico configuracao = configuracoes.SingleOrDefault(x => x.Id == (int)eServico.CredenciadoInutilizadoExcluir) ?? new ConfiguracaoServico();
try
{
DateTime inicio = configuracao.DataInicioExecucao ?? DateTime.MinValue;
if (configuracao == null || configuracao.Id <= 0 || configuracao.EmExecucao || (DateTime.Now - inicio) < configuracao.Intervalo)
{
return;
}
//Coloca o serviço em execução
configuracao.EmExecucao = true;
_da.EditarConfiguracao(configuracao, bancoDeDados);
_da.CredenciadoInutilizadoExcluir(bancoDeDados);
configuracao.EmExecucao = false;
_da.EditarConfiguracao(configuracao, bancoDeDados);
}
catch (Exception exc)
{
//finaliza o serviço em execução
//configuracao.EmExecucao = false;
//_da.EditarConfiguracao(configuracao, bancoDeDados);
throw exc;
}
}
}
public ServicosNFe CreateInstance4()
{
var conf = new ConfiguracaoServico();
var cert = new ConfiguracaoCertificado
{
TipoCertificado = TipoCertificado.A1Arquivo,
Arquivo = @"D:\Works\ProductInvoices\A1_NFE_08765239000164_cer2017.pfx",
Senha = "cer2017"
};
conf.Certificado = cert;
conf.tpAmb = NFeClasses.Informacoes.Identificacao.Tipos.TipoAmbiente.taHomologacao;
conf.cUF = DFe.Classes.Entidades.Estado.SP;
conf.tpEmis = NFeClasses.Informacoes.Identificacao.Tipos.TipoEmissao.teNormal;
conf.TimeOut = 120000;
conf.DiretorioSalvarXml = @"D:\Works\";
conf.SalvarXmlServicos = true;
conf.ModeloDocumento = DFe.Classes.Flags.ModeloDocumento.NFe;
conf.ProtocoloDeSeguranca = System.Net.SecurityProtocolType.Ssl3;
conf.DiretorioSchemas = @"D:\Works\Schemas\";
conf.VersaoNFeAutorizacao = VersaoServico.ve400;
conf.VersaoNfeDownloadNF = VersaoServico.ve400;
conf.VersaoNfeStatusServico = VersaoServico.ve400;
conf.VersaoNFeRetAutorizacao = VersaoServico.ve400;
return(new ServicosNFe(conf));
}
public GeradorDeNfce(ConfiguracaoServico cfgServico, X509Certificate2 cert)
{
_cfgServico = cfgServico;
var emitente = new emit
{
CNPJ = "31808064000147",
IE = "9079550016",
// ambiente produção
//xFant = "Joao Victor Spinoza",
//xNome = "Joao Victor Spinoza",
xNome = nfeEmitadaHomolog,
xFant = nfeEmitadaHomolog,
CRT = CRT.SimplesNacional
};
var configuracaoDeEmail = new ConfiguracaoEmail("*****@*****.**", "senha", "Envio de NFE", "Teset123", "smtp.dominio.com", 587, true, true);
var configuracaoDanfeNfe =
new ConfiguracaoDanfeNfce(NfceDetalheVendaNormal.UmaLinha, NfceDetalheVendaContigencia.UmaLinha, versaoQrCode: VersaoQrCode.QrCodeVersao2);
_configuracoes = new Configuracao(
GetEnderecoEmitente(),
_cfgServico,
emitente,
configuracaoDeEmail,
configuracaoDanfeNfe
);
_cert = cert;
_configuracoes.CfgServico.Certificado.Serial = _cert.SerialNumber;
}
public ServicosNfce()
{
CfgServico = ConfiguracaoServico.Instancia;
CfgServico.tpAmb = TipoAmbiente.Homologacao;
CfgServico.tpEmis = TipoEmissao.teNormal;
CfgServico.ProtocoloDeSeguranca = ServicePointManager.SecurityProtocol;
}
/// <summary>
/// Cria o cliente <see cref="SoapHttpClientProtocol"/> para o serviço de Autorização
/// </summary>
/// <param name="cfg">Configuração do serviço</param>
/// <param name="certificado">Certificado</param>
/// <returns></returns>
public static INfeServicoAutorizacao CriaWsdlAutorizacao(ConfiguracaoServico cfg, X509Certificate2 certificado)
{
var url = Enderecador.ObterUrlServico(ServicoNFe.NFeAutorizacao, cfg);
if (cfg.UsaSvanNFe4(cfg.VersaoNFeAutorizacao))
{
return(new NFeAutorizacao4SVAN(url, certificado, cfg.TimeOut));
}
if (cfg.UsaSvcanNFe4(cfg.VersaoNFeAutorizacao))
{
return(new NFeAutorizacao4SVCAN(url, certificado, cfg.TimeOut));
}
if (cfg.VersaoNFeAutorizacao == VersaoServico.ve400)
{
return(new NFeAutorizacao4(url, certificado, cfg.TimeOut));
}
if (cfg.cUF == Estado.PR & cfg.VersaoNFeAutorizacao == VersaoServico.ve310)
{
return(new NfeAutorizacao3(url, certificado, cfg.TimeOut));
}
return(new NfeAutorizacao(url, certificado, cfg.TimeOut));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
ConfiguracaoServico.ConfiguracaoDependenciaServico(services);
ConfiguracaoRepositorio.ConfiguracaoRepositorioDependencia(services);
services.AddControllers();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1",
new OpenApiInfo
{
Title = "API HORAS DESENVOLVEDOR",
Version = "v1",
Description = "API REST criada com o ASP.NET Core para Controle Horas Devs" +
"Em Desenvolvimento! Devido ao trabalho atual, não tive tempo para implantar:" +
" - A camada BO no services. GetFiveTop()" +
" - Não implantei o Jwt. " +
" - Não implantei tambem o apontamento dos serviços externo para validação" +
"......a aplicação esta incompleta mas possui arquitetura rica destinada ao mercado!!!",
Contact = new OpenApiContact
{
Name = "Guilherme Felix Silva",
Email = "*****@*****.**",
Url = new Uri("https://www.linkedin.com/in/guilhermefdsilva/")
}
});
});
}
public CancelarNFeServico(ConfiguracaoServico cfgServico, IStorage storage, ITransmitirSefazCommand transmitir)
{
this.cfgServico = cfgServico;
this.storage = storage;
this.transmitir = transmitir;
versao = "1.00";
}
/// <summary>
/// Cria o cliente <see cref="SoapHttpClientProtocol"/> para o serviço de Autorização
/// </summary>
/// <param name="cfg">Configuração do serviço</param>
/// <param name="certificado">Certificado</param>
/// <returns></returns>
public static INfeServicoAutorizacao CriaWsdlAutorizacao(ConfiguracaoServico cfg, X509Certificate2 certificado, bool compactarMensagem)
{
string url = Enderecador.ObterUrlServico(ServicoNFe.NFeAutorizacao, cfg);
if (cfg.UsaSvanNFe4(cfg.VersaoNFeAutorizacao))
{
return(new NFeAutorizacao4SVAN(url, certificado, cfg.TimeOut));
}
if (cfg.UsaSvcanNFe4(cfg.VersaoNFeAutorizacao))
{
return(new NFeAutorizacao4SVCAN(url, certificado, cfg.TimeOut));
}
if (cfg.VersaoNFeAutorizacao == VersaoServico.Versao400)
{
return(new NFeAutorizacao4(url, certificado, cfg.TimeOut, compactarMensagem, ConverteVersaoLayout(cfg.VersaoNFeAutorizacao), cfg.cUF));
}
if (cfg.cUF == Estado.PR & cfg.VersaoNFeAutorizacao == VersaoServico.Versao310)
{
return(new NfeAutorizacao3(url, certificado, cfg.TimeOut));
}
return(new NfeAutorizacao(url, certificado, cfg.TimeOut));
}
public void NFeConfiguracaoServico_WhenTryCallAsynchronously_ReturnsCorrectStateDistinctNumbers()
{
// Arrange
var config1 = new { State = Estado.AC, SleepTime = TimeSpan.FromSeconds(10) };
var config2 = new { State = Estado.AM, SleepTime = TimeSpan.FromSeconds(2) };
var config3 = new { State = Estado.AP, SleepTime = TimeSpan.FromSeconds(0) };
var config4 = new { State = Estado.SP, SleepTime = TimeSpan.FromSeconds(3) };
var configurations = new[] { config1, config2, config3, config4 };
var result = new List <Estado>();
// Act
foreach (var config in configurations)
{
Task.Run(() =>
{
var service = new ConfiguracaoServico();
service.cUF = config.State;
Thread.Sleep(config.SleepTime);
result.Add(service.cUF);
}
);
}
// Assert
Thread.Sleep(TimeSpan.FromSeconds(12));
Assert.IsNotNull(result);
Assert.AreEqual(result.Distinct().Count(), 4);
}
public static UrlCTe ObterUrlServico(ConfiguracaoServico configuracaoServico = null)
{
var configServico = configuracaoServico ?? ConfiguracaoServico.Instancia;
switch (configServico.tpAmb)
{
case TipoAmbiente.Homologacao:
if (configServico.TipoEmissao == tpEmis.teSVCRS)
{
return(UrlHomologacaoSvrs());
}
if (configServico.TipoEmissao == tpEmis.teSVCSP)
{
return(UrlHomologacaoSvcsp());
}
return(UrlHomologacao(configServico));
case TipoAmbiente.Producao:
if (configServico.TipoEmissao == tpEmis.teSVCRS)
{
return(UrlProducaoSvrs());
}
if (configServico.TipoEmissao == tpEmis.teSVCSP)
{
return(UrlProducaoSvcsp());
}
return(UrlProducao(configServico));
}
throw new InvalidOperationException("Tipo Ambiente inválido");
}
/// <summary>
/// Assina um objeto CTe
/// </summary>
/// <param name="cte"></param>
/// <param name="configuracaoServico"></param>
/// <returns>Retorna um objeto do tipo CTe assinado</returns>
public static void Assina(this CteEletronica cte, ConfiguracaoServico configuracaoServico = null)
{
if (cte == null)
{
throw new ArgumentNullException("cte");
}
var configServico = configuracaoServico ?? ConfiguracaoServico.Instancia;
var modeloDocumentoFiscal = cte.infCte.ide.mod;
var tipoEmissao = (int)cte.infCte.ide.tpEmis;
var codigoNumerico = cte.infCte.ide.cCT;
var estado = cte.infCte.ide.cUF;
var dataEHoraEmissao = cte.infCte.ide.dhEmi;
var cnpj = cte.infCte.emit.CNPJ;
var numeroDocumento = cte.infCte.ide.nCT;
int serie = cte.infCte.ide.serie;
var dadosChave = ChaveFiscal.ObterChave(estado, dataEHoraEmissao, cnpj, modeloDocumentoFiscal, serie, numeroDocumento, tipoEmissao, codigoNumerico);
cte.infCte.Id = "CTe" + dadosChave.Chave;
cte.infCte.versao = configServico.VersaoLayout;
cte.infCte.ide.cDV = dadosChave.DigitoVerificador;
var assinatura = AssinaturaDigital.Assina(cte, cte.infCte.Id, configServico.X509Certificate2);
cte.Signature = assinatura;
}
internal List <ConfiguracaoServico> Configuracoes(eServico servico)
{
List <ConfiguracaoServico> retorno = new List <ConfiguracaoServico>();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(EsquemaBanco))
{
Comando comando = bancoDeDados.CriarComando(@"select id, servico, intervalo, data_inicio, data_inicio_execucao,
nvl(data_ultima_execucao, data_inicio) data_ultima_execucao, em_execucao, tid from cnf_servicos t" );
comando.DbCommand.CommandText += " where t.id = :servico";
comando.AdicionarParametroEntrada("servico", (int)servico, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
ConfiguracaoServico conf;
while (reader.Read())
{
conf = new ConfiguracaoServico();
conf.Id = reader.GetValue <Int32>("id");
conf.Servico = reader.GetValue <String>("servico");
conf.Intervalo = new TimeSpan(reader.GetValue <Int32>("intervalo"), 0, 0); //Em Horas
conf.DataInicio = reader.GetValue <DateTime>("data_inicio");
conf.DataInicioExecucao = reader.GetValue <DateTime>("data_inicio_execucao");
conf.DataUltimaExecucao = reader.GetValue <DateTime>("data_ultima_execucao");
conf.EmExecucao = reader.GetValue <Boolean>("em_execucao");
retorno.Add(conf);
}
reader.Close();
}
return(retorno);
}
}
internal void EditarConfiguracao(ConfiguracaoServico configuracao, BancoDeDados banco = null)
{
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
bancoDeDados.IniciarTransacao();
Comando comando;
if (configuracao.EmExecucao)
{
comando = bancoDeDados.CriarComando(@"update cnf_servicos r set r.data_inicio_execucao = :data_inicio_execucao, r.em_execucao = :em_execucao, r.tid = :tid where r.id = :id");
configuracao.DataInicioExecucao = configuracao.DataInicioExecucao.Value.AddHours(configuracao.Intervalo.TotalHours);
comando.AdicionarParametroEntrada("data_inicio_execucao", configuracao.DataInicioExecucao, DbType.DateTime);
}
else
{
comando = bancoDeDados.CriarComando(@"update cnf_servicos r set r.data_ultima_execucao = sysdate, r.em_execucao = :em_execucao, r.tid = :tid where r.id = :id");
}
comando.AdicionarParametroEntrada("id", configuracao.Id, DbType.Int32);
comando.AdicionarParametroEntrada("em_execucao", configuracao.EmExecucao ? 1 : 0, DbType.Int32);
comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
bancoDeDados.ExecutarNonQuery(comando);
bancoDeDados.Commit();
}
}
/// <summary>
/// Responsavel Consultar Status do Serviço da Sefaz
/// </summary>
/// <returns></returns>
public RetornoNfeStatusServico ConsultarStatusServico(ConfiguracaoServico cFgServico)
{
var servicoNFe = new ServicosNFe(cFgServico);
var retornoStatus = servicoNFe.NfeStatusServico();
return(retornoStatus);
}
public ServicosNFe CreateInstance4()
{
_conf = new ConfiguracaoServico();
var cert = new ConfiguracaoCertificado
{
TipoCertificado = TipoCertificado.A1Arquivo,
Arquivo = @"certificatePath.pfx",
Senha = "certificatePassword"
};
_conf.Certificado = cert;
_conf.ModeloDocumento = DFe.Classes.Flags.ModeloDocumento.NFCe; // Condition
_conf.tpAmb = NFeClasses.Informacoes.Identificacao.Tipos.TipoAmbiente.taProducao;
_conf.cUF = DFe.Classes.Entidades.Estado.SP;
_conf.tpEmis = NFeClasses.Informacoes.Identificacao.Tipos.TipoEmissao.teNormal;
_conf.TimeOut = 120000;
_conf.DiretorioSalvarXml = @"D:\works\nfce";
_conf.SalvarXmlServicos = true;
_conf.ProtocoloDeSeguranca = System.Net.SecurityProtocolType.Tls12;
_conf.DiretorioSchemas = @"C:\Works\nfe\nfe-products-api\schemas";
_conf.VersaoNFeAutorizacao = VersaoServico.ve400;
_conf.VersaoNfeDownloadNF = VersaoServico.ve400;
_conf.VersaoNfeStatusServico = VersaoServico.ve400;
_conf.VersaoNFeRetAutorizacao = VersaoServico.ve400;
return(new ServicosNFe(_conf));
}
public ManifestacaoDestinatarioServico(ConfiguracaoServico config, IStorage storage, ITransmitirSefazCommand transmitir)
{
this.config = config;
this.storage = storage;
this.transmitir = transmitir;
this.nSeqEvento = 1;
}
public static void SalvarXmlEmDisco(this retCTeOS retEnviCte, ConfiguracaoServico config)
{
if (config.NaoSalvarXml())
{
return;
}
var dataEnvio = DateTimeOffset.Now;
if (retEnviCte != null && retEnviCte.protCTe != null &&
retEnviCte.protCTe.infProt != null &&
retEnviCte.protCTe.infProt.dhRecbto != null)
{
dataEnvio = retEnviCte.protCTe.infProt.dhRecbto;
}
var caminhoXml = config.DiretorioSalvarXml;
var protocolo = "000000";
if (retEnviCte != null && retEnviCte.protCTe != null &&
retEnviCte.protCTe.infProt != null &&
retEnviCte.protCTe.infProt.nProt != null)
{
protocolo = retEnviCte.protCTe.infProt.nProt;
}
var arquivoSalvar = Path.Combine(caminhoXml, new StringBuilder(protocolo).Append("-rec.xml").ToString());
FuncoesXml.ClasseParaArquivoXml(retEnviCte, arquivoSalvar);
}
/// <summary>
/// Responsavel por Enviar NFe para Sefaz
/// </summary>
/// <param name="cFgServico"></param>
/// <param name="numLote"></param>
/// <param name="nfe"></param>
/// <returns></returns>
public RetornoNFeAutorizacao EnviarNFe(int numLote, Classes.NFe nfe, ConfiguracaoServico cFgServico)
{
//nfe.Assina(cFgServico); //não precisa validar aqui, pois o lote será validado em ServicosNFe.NFeAutorizacao
var servicoNFe = new ServicosNFe(cFgServico);
var retornoEnvio = servicoNFe.NFeAutorizacao(numLote, IndicadorSincronizacao.Assincrono, new List <Classes.NFe> {
nfe
}, false /*Envia a mensagem compactada para a SEFAZ*/);
var recibo = servicoNFe.NFeRetAutorizacao(retornoEnvio.Retorno.infRec.nRec);
var cStat = this.VerificarcStat(recibo.RetornoCompletoStr, "protNFe", "infProt");
if (cStat == "100")
{
//Salva NFe+protNFe na tag nfeProc apos autorização da NFe
this.AdicionarNFeProc(nfe.infNFe.Id.Substring(3), nfe, cFgServico);
}
if (nfe.infNFe.ide.mod == ModeloDocumento.NFCe)
{
this.SalvarXmlArquivo(nfe.infNFe.Id.Substring(3) + "-nfce", nfe.ObterXmlString(), cFgServico.tpAmb);
}
else
{
this.SalvarXmlArquivo(nfe.infNFe.Id.Substring(3) + "-nfe", nfe.ObterXmlString(), cFgServico.tpAmb);
}
return(retornoEnvio);
}
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 static CteRecepcaoEvento CriaWsdlCteEvento(ConfiguracaoServico configuracaoServico = null)
{
var url = UrlHelper.ObterUrlServico(configuracaoServico).CteRecepcaoEvento;
var configuracaoWsdl = CriaConfiguracao(url, configuracaoServico);
return(new CteRecepcaoEvento(configuracaoWsdl));
}
/// <summary>
/// Cria uma instância da Classe responsável pelos serviços relacionados à NFe
/// </summary>
/// <param name="cFgServico"></param>
public ServicosNFe(ConfiguracaoServico cFgServico)
{
_cFgServico = cFgServico;
_certificado = string.IsNullOrEmpty(_cFgServico.Certificado.Arquivo)
? CertificadoDigital.ObterDoRepositorio(_cFgServico.Certificado.Serial, _cFgServico.Certificado.Senha)
: CertificadoDigital.ObterDeArquivo(_cFgServico.Certificado.Arquivo, _cFgServico.Certificado.Senha);
_path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
}
public static CteConsulta CriaWsdlConsultaProtocolo(ConfiguracaoServico configuracaoServico = null)
{
var url = UrlHelper.ObterUrlServico(configuracaoServico).CteConsulta;
var configuracaoWsdl = CriaConfiguracao(url, configuracaoServico);
return(new CteConsulta(configuracaoWsdl));
}
public static CteInutilizacao CriaWsdlCteInutilizacao(ConfiguracaoServico configuracaoServico = null)
{
var url = UrlHelper.ObterUrlServico(configuracaoServico).CteInutilizacao;
var configuracaoWsdl = CriaConfiguracao(url, configuracaoServico);
return(new CteInutilizacao(configuracaoWsdl));
}
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 static CTeDistDFeInteresse CriaWsdlCTeDistDFeInteresse(ConfiguracaoServico configuracaoServico = null)
{
var url = UrlHelper.ObterUrlServico(configuracaoServico).CTeDistribuicaoDFe;
var configuracaoWsdl = CriaConfiguracao(url, configuracaoServico);
return(new CTeDistDFeInteresse(configuracaoWsdl));
}
/// <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
);
}
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);
}
