Пример #1
0
        async Task <RetConsReciNFe> ConsultarRespostaFinal(RetEnviNFe retTransmissao, bool homologacao)
        {
            var gerenciador = new GerenciadorGeral <ConsReciNFe, RetConsReciNFe>(
                retTransmissao.Estado, Operacoes.RespostaAutorizar, homologacao, true);
            var envio = new ConsReciNFe(retTransmissao.TipoAmbiente, retTransmissao.DadosRecibo.NumeroRecibo);

            return(await gerenciador.EnviarAsync(envio));
        }
Пример #2
0
 public void BtMenuPrincipal()
 {
     telaAtual = 0;
     if (GerenciadorGeral.modoOnline)
     {
         GerenciadorGeral.DesconectarRede();
     }
 }
Пример #3
0
        async Task <RetEnviNFe> ConsultarRespostaInicial(bool homologacao)
        {
            var nota        = (NFe)ItemCompleto;
            var uf          = nota.Informacoes.Emitente.Endereco.SiglaUF;
            var gerenciador = new GerenciadorGeral <EnviNFe, RetEnviNFe>(uf, Operacoes.Autorizar, nota.AmbienteTestes, false);
            var envio       = new EnviNFe(nota);

            return(await gerenciador.EnviarAsync(envio, true));
        }
Пример #4
0
 public void MiniJogo()
 {
     if (GerenciadorPartida.InvAtual.moedas >= 25)
     {
         GerenciadorGeral.TransitarParaMJ(minijogo);
     }
     else
     {
         GPWaitRodada();
     }
 }
Пример #5
0
        private async void Analisar(object sender, RoutedEventArgs e)
        {
            if (UF == null || string.IsNullOrEmpty(Chave))
            {
                return;
            }
            var gerenciador = new GerenciadorGeral <ConsSitNFe, RetConsSitNFe>(UF, Operacoes.Consultar, Homologacao, isNFCe);
            var envio       = new ConsSitNFe(Chave, Homologacao);

            RetConsSitNFe resultado = default(RetConsSitNFe);

            X509Certificate2[] certs;
            using (var loja = new X509Store(StoreName.My, StoreLocation.CurrentUser))
            {
                loja.Open(OpenFlags.ReadOnly);
                certs = loja.Certificates.Cast <X509Certificate2>().ToArray();
            }
            Progresso progresso = null;

            progresso = new Progresso(async x =>
            {
                resultado = await gerenciador.EnviarAsync(envio, false, (X509Certificate2)x);
                await progresso.Update(5);
                return(true, resultado.DescricaoResposta);
            }, certs, "Subject", gerenciador.Etapas.Concat("Analisar resultado no banco de dados"));
            gerenciador.ProgressChanged += async(x, y) => await progresso.Update(y);

            await progresso.ShowAsync();

            if (resultado.StatusResposta == 100)
            {
                NFeDI nota = null;
                using (var leit = new BaseGeral.Repositorio.Leitura())
                {
                    nota = leit.ObterNota($"NFe{resultado.ChaveNFe}");
                }
                if (nota != null && nota.Status < 4)
                {
                    using (var esc = new BaseGeral.Repositorio.Escrita())
                    {
                        nota.Status = (int)StatusNota.Emitida;
                        var original = XElement.Parse(nota.XML).FromXElement <NFe>();
                        var novo     = new ProcessoNFe()
                        {
                            NFe     = original,
                            ProtNFe = resultado.Protocolo
                        };
                        nota.XML = novo.ToXElement().ToString();
                        esc.SalvarItemSimples(nota, DefinicoesTemporarias.DateTimeNow);
                    }
                }
            }
        }
Пример #6
0
        public void BtIniciarPartida()
        {
            if (GerenciadorGeral.modoOnline && PhotonNetwork.IsMasterClient)
            {
                var room = PhotonNetwork.CurrentRoom;
                if (room == null)
                {
                    return;
                }

                GerenciadorGeral.qtdJogadores = room.PlayerCount;
                GerenciadorGeral.SyncClientesQtdJogadores();
            }


            GerenciadorGeral.TransitarParaMJ(CenaID.Tabuleiro);
        }
Пример #7
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();
            }
        }
Пример #8
0
        void AtualizaListaVisualJogadores()
        {
            for (int i = 0; i < 4; i++)
            {
                var   qtdJogadores = GerenciadorGeral.qtdJogadores;
                Color corFinal     = i < qtdJogadores ? Color.white : Color.grey;

                var duendeSprites = listaJogadores
                                    .GetChild(i)
                                    .GetChild(0)
                                    .GetComponent <MudaSpritePorJogador>();

                duendeSprites.cabeca.color = corFinal;
                duendeSprites.corpo.color  = corFinal;
                duendeSprites.manga.color  = corFinal;
                duendeSprites.mao.color    = corFinal;
            }

            adicionarJogador.interactable = GerenciadorGeral.PodeCadastrar();
            removerJogador.interactable   = GerenciadorGeral.PodeDecadastrar();
        }
Пример #9
0
        void AtualizaVisualEstadoDeJogo()
        {
            if (estadoJogo_fmt == "")
            {
                estadoJogo_fmt = txtEstadoDeJogo.text;
            }

            string estadoDeJogo_str = string.Format(
                estadoJogo_fmt,
                GerenciadorGeral.qtdJogadores,
                GerenciadorGeral.pontuacao[0],
                GerenciadorGeral.pontuacao[1],
                GerenciadorGeral.pontuacao[2],
                GerenciadorGeral.pontuacao[3]
                );

            txtEstadoDeJogo.text = estadoDeJogo_str;

            btCadastrarJogador.interactable   = GerenciadorGeral.PodeCadastrar();
            btDecadastrarJogador.interactable = GerenciadorGeral.PodeDecadastrar();
        }
Пример #10
0
        void DefAtivacao(bool def)
        {
            Debug.Log("DEFATIVACAO" + def.ToString(), gameObject);
            tronco_gbj.SetActive(def);

            if (def) // deve ir ao tabuleiro
            {
                SceneManager.MoveGameObjectToScene(
                    _instancia.gameObject,
                    cenaOriginal
                    );
                _instancia.Reinicializa();
            }
            else // deve ir ao DontDestroyOnLoad
            {
                SceneManager.MoveGameObjectToScene(
                    _instancia.gameObject,
                    GerenciadorGeral.ObterInstancia().gameObject.scene
                    );
            }
        }
Пример #11
0
        async Task <RetConsReciNFe> ConsultarRespostaFinal(RetEnviNFe retTransmissao, bool homologacao)
        {
            if (retTransmissao == null)
            {
                throw new AnaliseErro("O resultado da transmissão inicial não é válido.");
            }
            GerenciadorGeral <ConsReciNFe, RetConsReciNFe> gerenciador;

            try
            {
                gerenciador = new GerenciadorGeral <ConsReciNFe, RetConsReciNFe>(
                    retTransmissao.Estado, Operacoes.RespostaAutorizar, homologacao, false);
            }
            catch (Exception e)
            {
                throw new AnaliseErro("Erro durante a criação do gerenciador.", e);
            }

            ConsReciNFe envio;

            try
            {
                envio = new ConsReciNFe(retTransmissao.TipoAmbiente, retTransmissao.DadosRecibo.NumeroRecibo);
            }
            catch (Exception e)
            {
                throw new AnaliseErro("Erro durante a criação do envio.", e);
            }

            try
            {
                return(await gerenciador.EnviarAsync(envio));
            }
            catch (Exception e)
            {
                throw new AnaliseErro("Erro durante o envio.", e);
            }
        }
Пример #12
0
 public void BtJogarRede()
 {
     telaAtual = 4;
     GerenciadorGeral.ConectarRede();
 }
Пример #13
0
 public void DecadastrarJogador()
 {
     GerenciadorGeral.DecadastrarJogador();
     AtualizaListaVisualJogadores();
 }
Пример #14
0
 public void IniciarMJ()
 {
     GerenciadorGeral.TransitarParaMJ(cenaMJ);
 }
Пример #15
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);
        }
Пример #16
0
 public void DecadastrarJogador()
 {
     GerenciadorGeral.DecadastrarJogador();
     AtualizaVisualEstadoDeJogo();
 }
Пример #17
0
 void AbrirMJ(CenaID cenaId)
 {
     GerenciadorGeral.TransitarParaMJ(cenaId);
 }