Ejemplo n.º 1
0
        public async Task <(bool, string)> PrepararEventos(AssinaFacil assinador, X509Certificate2 cert)
        {
            for (int i = 0; i < Eventos.Length; i++)
            {
                var evento = Eventos[i];
                assinador.Nota = evento;
                var resposta = await assinador.Assinar <Evento>(cert, evento.InfEvento.Id, "infEvento");

                if (!resposta.Item1)
                {
                    return(false, resposta.Item2);
                }
            }
            return(true, "Documento assinado com sucesso.");
        }
Ejemplo n.º 2
0
        async void AdicionarInutilizacao(object sender, RoutedEventArgs e)
        {
            var caixa = new InfoInutilizacao();

            if (await caixa.ShowAsync() == ContentDialogResult.Primary)
            {
                var envio = new InutNFe(new InfInut(caixa.Homologacao, caixa.Serie, caixa.InicioNum, caixa.FimNum, caixa.Justificativa));

                var uf          = DefinicoesTemporarias.EmitenteAtivo.SiglaUF;
                var gerenciador = new GerenciadorGeral <InutNFe, RetInutNFe>(uf, Operacoes.Inutilizacao, caixa.Homologacao, isNFCe);

                AssinaFacil assinador = new AssinaFacil();
                Progresso   progresso = null;
                progresso = new Progresso(async x =>
                {
                    var cert         = (X509Certificate2)x;
                    var resultAssina = await envio.PrepararEvento(assinador, cert);
                    if (!resultAssina.Item1)
                    {
                        return(resultAssina);
                    }
                    await progresso.Update(1);

                    var resultado = await gerenciador.EnviarAsync(envio);
                    var sucesso   = resultado.Info.StatusResposta == 102;
                    if (sucesso)
                    {
                        Concluir(resultado, caixa.Homologacao);
                        await progresso.Update(6);
                    }
                    return(sucesso, resultado.Info.DescricaoResposta);
                }, assinador.CertificadosDisponiveis, "Subject",
                                          "Assinar documentos para envio",
                                          "Preparar conexão",
                                          "Obter conteúdo da requisição",
                                          "Enviar requisição",
                                          "Processar resposta",
                                          "Salvar retorno no banco de dados");
                gerenciador.ProgressChanged += async(x, y) => await progresso.Update(y + 1);

                await progresso.ShowAsync();
            }
        }
Ejemplo n.º 3
0
        public async Task <bool> Cancelar(NFeDI nota)
        {
            bool retorno     = true;
            var  processo    = XElement.Parse(nota.XML).FromXElement <ProcessoNFCe>();
            var  informacoes = processo.NFe.Informacoes;
            var  protNFe     = processo.ProtNFe;

            var estado       = informacoes.identificacao.CódigoUF;
            var cnpj         = informacoes.Emitente.CNPJ;
            var chave        = informacoes.ChaveAcesso;
            var tipoAmbiente = protNFe.InfProt.tpAmb;
            var nProtocolo   = protNFe.InfProt.nProt;

            var entrada = new CancelarNFe();

            if (await entrada.ShowAsync() == ContentDialogResult.Primary)
            {
                var infoEvento = new InformacoesEvento(estado, cnpj, chave, nProtocolo, entrada.Motivo, tipoAmbiente);
                var envio      = new EnvEvento(infoEvento);

                AssinaFacil assinador   = new AssinaFacil();
                var         gerenciador = new GerenciadorGeral <EnvEvento, RetEnvEvento>(estado, Operacoes.RecepcaoEvento, tipoAmbiente == 2, true);
                Progresso   progresso   = null;
                progresso = new Progresso(async x =>
                {
                    var cert      = (X509Certificate2)x;
                    var resultado = await envio.PrepararEventos(assinador, cert);
                    if (!resultado.Item1)
                    {
                        retorno = resultado.Item1;
                        return(resultado);
                    }
                    await progresso.Update(1);

                    var resposta = await gerenciador.EnviarAsync(envio);
                    if (resposta.ResultadorEventos[0].InfEvento.CStat == 135)
                    {
                        using (var repo = new BaseGeral.Repositorio.Escrita())
                        {
                            var xml = new ProcEventoCancelamento()
                            {
                                Eventos   = envio.Eventos,
                                RetEvento = resposta.ResultadorEventos,
                                Versao    = resposta.Versao
                            }.ToXElement <ProcEventoCancelamento>();
                            repo.SalvarItemSimples(new RegistroCancelamento()
                            {
                                ChaveNFe       = chave,
                                DataHoraEvento = resposta.ResultadorEventos[0].InfEvento.DhRegEvento,
                                TipoAmbiente   = tipoAmbiente,
                                XML            = xml.ToString()
                            }, DefinicoesTemporarias.DateTimeNow);

                            nota.Status = (int)StatusNota.Cancelada;
                            repo.SalvarItemSimples(nota, DefinicoesTemporarias.DateTimeNow);
                            await progresso.Update(6);

                            using (var opEx = new BaseGeral.Repositorio.OperacoesExtras())
                            {
                                var rvVinculado = opEx.GetRVVinculado(informacoes.Id);
                                if (rvVinculado != null)
                                {
                                    if (rvVinculado.Cancelado)
                                    {
                                        var dialog = new MessageDialog("Um registro de venda já cancelado está vinculado a esta nota fiscal, você ainda deseja aplicar as alterações no estoque?", "Aviso");
                                        dialog.Commands.Add(new UICommand("Sim", y => AtualizarEstoques()));
                                        dialog.Commands.Add(new UICommand("Não"));
                                        await dialog.ShowAsync();
                                    }
                                    else
                                    {
                                        var dialog = new MessageDialog("Um registro de venda válido está vinculado a esta nota fiscal, você ainda deseja aplicar as alterações no estoque?", "Aviso");
                                        dialog.Commands.Add(new UICommand("Sim", y => AtualizarEstoques()));
                                        dialog.Commands.Add(new UICommand("Não"));
                                        await dialog.ShowAsync();

                                        dialog = new MessageDialog("Esta nota foi cancelada com sucesso, você deseja também cancelar o registro de venda?", "Aviso");
                                        dialog.Commands.Add(new UICommand("Sim", y =>
                                        {
                                            using (var escr = new BaseGeral.Repositorio.Escrita())
                                            {
                                                escr.CancelarRV(rvVinculado, new CancelamentoRegistroVenda()
                                                {
                                                    Id = rvVinculado.Id,
                                                    MomentoCancelamento = DefinicoesTemporarias.DateTimeNow,
                                                    Motivo = "Cancelamento decorrente de cancelamento da nota fiscal correspondente."
                                                }, DefinicoesTemporarias.DateTimeNow);
                                            }
                                        }));
                                        dialog.Commands.Add(new UICommand("Não"));
                                        await dialog.ShowAsync();
                                    }
                                }
                                else
                                {
                                    AtualizarEstoques();
                                }
                            }

                            void AtualizarEstoques()
                            {
                                using (var leit = new BaseGeral.Repositorio.Leitura())
                                {
                                    repo.AtualizarEstoques(DefinicoesTemporarias.DateTimeNow,
                                                           (from prod in informacoes.produtos
                                                            let orig = leit.ObterProduto(prod.Produto.CodigoProduto)
                                                                       where orig != null
                                                                       select(orig.Id, prod.Produto.QuantidadeComercializada)).ToArray());
                                }
                            }
                        }
                        retorno = true;
                        return(true, "NFe cancelada com sucesso.");
                    }
                    else
                    {
                        retorno = false;
                        return(false, resposta.ResultadorEventos[0].InfEvento.XMotivo);
                    }
                }, assinador.CertificadosDisponiveis, "Subject",
                                          "Preparar eventos com assinatura do emitente",
                                          "Preparar conexão",
                                          "Obter conteúdo da requisição",
                                          "Enviar requisição",
                                          "Processar resposta",
                                          "Salvar registro de cancelamento no banco de dados");
                gerenciador.ProgressChanged += async(x, y) => await progresso.Update(y + 1);

                await progresso.ShowAsync();
            }
            return(retorno);
        }
Ejemplo n.º 4
0
 public async Task <(bool, string)> PrepararEvento(AssinaFacil assinador, X509Certificate2 cert)
 {
     assinador.Nota = this;
     return(await assinador.Assinar <InutNFe>(cert, Info.Id, "infInut"));
 }