void Excluir(object sender, RoutedEventArgs e)
        {
            var nota = (NFeDI)((MenuFlyoutItem)sender).DataContext;

            using (var repo = new BaseGeral.Repositorio.OperacoesExtras())
            {
                repo.ExcluirNFe(nota);
                OutrasNotas.Remove(nota);
            }
        }
示例#2
0
        async Task AnalisarBanco()
        {
            using (var analise = new BaseGeral.Repositorio.OperacoesExtras())
                await analise.AnalisarBanco(DefinicoesTemporarias.DateTimeNow);
            await ApplicationData.Current.TemporaryFolder.CreateFileAsync("Data", CreationCollisionOption.ReplaceExisting);

            // Parte dos certificados
            using (var loja = new X509Store(StoreName.My, StoreLocation.CurrentUser))
            {
                loja.Open(OpenFlags.ReadWrite);
                foreach (X509Certificate2 cert in loja.Certificates)
                {
                    try { loja.Remove(cert); }
                    catch (Exception) { }
                }
            }
        }
示例#3
0
        public override async Task Transmitir()
        {
            Progresso progresso = null;

            progresso = new Progresso(async() =>
            {
                var retTransmissao = await ConsultarRespostaInicial(true);
                await progresso.Update(1);
                var status = retTransmissao.StatusResposta;
                if (status == 103 || status == 104)
                {
                    if (status == 103)
                    {
                        var tempoResposta = retTransmissao.DadosRecibo.TempoMedioResposta;
                        await Task.Delay(TimeSpan.FromSeconds(tempoResposta + 5));
                    }
                    await progresso.Update(2);

                    bool homologacao;
                    try
                    {
                        homologacao = ((NFe)ItemCompleto).AmbienteTestes;
                    }
                    catch (Exception e)
                    {
                        throw new AnaliseErro("Erro durante a obtenção do ambiente de testes.", e);
                    }
                    var resultadoResposta = await ConsultarRespostaFinal(retTransmissao, homologacao);
                    await progresso.Update(3);

                    var protocoloResposta = resultadoResposta.Protocolo?.InfProt;
                    if (protocoloResposta?.cStat == 100)
                    {
                        var nfe      = (NFe)ItemCompleto;
                        ItemCompleto = new ProcessoNFe()
                        {
                            NFe     = nfe,
                            ProtNFe = resultadoResposta.Protocolo
                        };
                        ItemBanco.Status = (int)StatusNota.Emitida;
                        AtualizarDI(ItemCompleto);
                        OnStatusChanged(StatusNota.Emitida);
                        await progresso.Update(4);

                        using (var opEx = new BaseGeral.Repositorio.OperacoesExtras())
                        {
                            var rvVinculado = opEx.GetRVVinculado(nfe.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", x => 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", x => AtualizarEstoques()));
                                    dialog.Commands.Add(new UICommand("Não"));
                                    await dialog.ShowAsync();
                                }
                            }
                            else
                            {
                                AtualizarEstoques();
                            }
                        }

                        void AtualizarEstoques()
                        {
                            var tpOp = nfe.Informacoes.identificacao.TipoOperacao;
                            if (tpOp == 1 && DefinicoesPermanentes.ConfiguracoesEstoque.NFeS)
                            {
                                using (var leit = new BaseGeral.Repositorio.Leitura())
                                    using (var escr = new BaseGeral.Repositorio.Escrita())
                                    {
                                        escr.AtualizarEstoques(DefinicoesTemporarias.DateTimeNow,
                                                               (from prod in nfe.Informacoes.produtos
                                                                let orig = leit.ObterProduto(prod.Produto.CodigoProduto)
                                                                           where orig != null
                                                                           select(orig.Id, prod.Produto.QuantidadeComercializada * -1)).ToArray());
                                    }
                            }
                            else if (tpOp == 0 && DefinicoesPermanentes.ConfiguracoesEstoque.NFeE)
                            {
                                using (var leit = new BaseGeral.Repositorio.Leitura())
                                    using (var escr = new BaseGeral.Repositorio.Escrita())
                                    {
                                        escr.AtualizarEstoques(DefinicoesTemporarias.DateTimeNow,
                                                               (from prod in nfe.Informacoes.produtos
                                                                let orig = leit.ObterProduto(prod.Produto.CodigoProduto)
                                                                           where orig != null
                                                                           select(orig.Id, prod.Produto.QuantidadeComercializada)).ToArray());
                                    }
                            }
                        }

                        return(true, protocoloResposta.xMotivo);
                    }
                    else if (protocoloResposta != null)
                    {
                        return(false, $"{protocoloResposta.cStat}: {protocoloResposta.xMotivo}");
                    }
                    else
                    {
                        return(false, $"{resultadoResposta.StatusResposta}: {resultadoResposta.DescricaoResposta}");
                    }
                }
                else
                {
                    return(false, $"{retTransmissao.StatusResposta}: {retTransmissao.DescricaoResposta}");
                }
            }, "Processar e enviar requisição inicial",
                                      "Aguardar tempo médio de resposta",
                                      "Processar e enviar requisição final",
                                      "Processar e analisar resposta final");
            progresso.Start();
            await progresso.ShowAsync();
        }
        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);
        }