Example #1
0
        public void ReprocessarBaseReferencia(SimuladorGeoArquivo arquivo)
        {
            try
            {
                GerenciadorTransacao.ObterIDAtual();

                using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(UsuarioPublicoGeo))
                {
                    arquivo.Mecanismo = (int)eSimuladorGeoMecanismo.Simulador;
                    arquivo.Etapa     = (int)eSimuladorGeoFilaEtapa.Processamento;
                    arquivo.Situacao  = (int)eSimuladorGeoFilaSituacao.Aguardando;

                    arquivo.IdRelacionamento = _da.ExisteArquivoFila(arquivo, bancoDeDados);

                    if (arquivo.IdRelacionamento == 0)
                    {
                        _da.InserirFila(arquivo, bancoDeDados);
                    }
                    else
                    {
                        _da.AlterarSituacaoFila(arquivo, bancoDeDados);
                    }

                    bancoDeDados.Commit();

                    _da.ObterSituacao(arquivo, bancoDeDados);
                }
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }
        }
        internal void ObterSituacao(SimuladorGeoArquivo arquivo, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                Comando comando = bancoDeDados.CriarComando(@"select t.id, t.texto from {0}lov_crt_projeto_geo_sit_proce t where t.etapa = :etapa and t.situacao = :situacao", EsquemaBanco);

                comando.AdicionarParametroEntrada("etapa", arquivo.Etapa, DbType.Int32);
                comando.AdicionarParametroEntrada("situacao", arquivo.Situacao, DbType.Int32);

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    if (reader.Read())
                    {
                        if (reader["id"] != null && !Convert.IsDBNull(reader["id"]))
                        {
                            arquivo.Situacao = Convert.ToInt32(reader["id"]);
                        }

                        if (reader["texto"] != null && !Convert.IsDBNull(reader["texto"]))
                        {
                            arquivo.SituacaoTexto = reader["texto"].ToString();
                        }
                    }
                    reader.Close();
                }
            }
        }
        public List <SimuladorGeoArquivo> ObterArquivos(int projetoId, BancoDeDados banco = null, bool finalizado = false)
        {
            List <SimuladorGeoArquivo> arquivos = new List <SimuladorGeoArquivo>();

            string tabela = finalizado ? "crt_projeto_geo_arquivos" : "tmp_projeto_geo_arquivos";

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Projeto Geográfico/Arquivos

                Comando comando = bancoDeDados.CriarComando(@"select  tf.id, t.tipo, lc.texto  tipo_texto, t.arquivo, t.valido, 
				lcp.id situacao_id, lcp.texto situacao_texto from {0}"                 + tabela + @" t, {0}lov_crt_projeto_geo_arquivos lc, {1}tab_fila tf, 
				{0}lov_crt_projeto_geo_sit_proce lcp where t.tipo = lc.id and t.projeto = tf.projeto(+) and t.tipo = tf.tipo(+) 
				and tf.etapa = lcp.etapa(+) and tf.situacao = lcp.situacao(+) and t.projeto = :projeto and t.valido = 1 and t.tipo <> 5 order by lc.id"                , EsquemaBanco, EsquemaBancoPublicoGeo);

                comando.AdicionarParametroEntrada("projeto", projetoId, DbType.Int32);

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    while (reader.Read())
                    {
                        SimuladorGeoArquivo arq = new SimuladorGeoArquivo();

                        if (reader["id"] != null && !Convert.IsDBNull(reader["id"]))
                        {
                            arq.IdRelacionamento = Convert.ToInt32(reader["id"]);
                        }

                        if (reader["tipo"] != null && !Convert.IsDBNull(reader["tipo"]))
                        {
                            arq.Nome = reader["tipo_texto"].ToString();
                            arq.Tipo = Convert.ToInt32(reader["tipo"]);
                        }

                        if (reader["arquivo"] != null && !Convert.IsDBNull(reader["arquivo"]))
                        {
                            arq.Id = Convert.ToInt32(reader["arquivo"]);
                        }

                        if (reader["situacao_id"] != null && !Convert.IsDBNull(reader["situacao_id"]))
                        {
                            arq.Situacao      = Convert.ToInt32(reader["situacao_id"]);
                            arq.SituacaoTexto = reader["situacao_texto"].ToString();
                        }

                        if (reader["valido"] != null && !Convert.IsDBNull(reader["valido"]))
                        {
                            arq.isValido = Convert.ToBoolean(reader["valido"]);
                        }

                        arquivos.Add(arq);
                    }

                    reader.Close();
                }

                #endregion
            }
            return(arquivos);
        }
        internal void InserirFila(SimuladorGeoArquivo arquivo, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();

                Comando comando = bancoDeDados.CriarComando(@"insert into {1}tab_fila f (id, projeto, tipo, mecanismo_elaboracao, etapa, situacao, data_fila)
				(select {1}seq_fila.nextval, t.id, :tipo, :mecanismo_elaboracao, :etapa, :situacao, sysdate from {0}tmp_projeto_geo t where t.id = :projeto)"                ,
                                                            EsquemaBanco, EsquemaBancoPublicoGeo);

                comando.AdicionarParametroEntrada("projeto", arquivo.ProjetoId, DbType.Int32);
                comando.AdicionarParametroEntrada("tipo", arquivo.Tipo, DbType.Int32);
                comando.AdicionarParametroEntrada("mecanismo_elaboracao", arquivo.Mecanismo, DbType.Int32);
                comando.AdicionarParametroEntrada("etapa", arquivo.Etapa, DbType.Int32);
                comando.AdicionarParametroEntrada("situacao", arquivo.Situacao, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                comando = bancoDeDados.CriarComando(@"select f.id from {0}tab_fila f where f.projeto = :projeto and f.tipo = :tipo", EsquemaBancoPublicoGeo);

                comando.AdicionarParametroEntrada("projeto", arquivo.ProjetoId, DbType.Int32);
                comando.AdicionarParametroEntrada("tipo", arquivo.Tipo, DbType.Int32);

                object valor = bancoDeDados.ExecutarScalar(comando);

                if (valor != null && !Convert.IsDBNull(valor))
                {
                    arquivo.IdRelacionamento = Convert.ToInt32(valor);
                }

                bancoDeDados.Commit();
            }
        }
Example #5
0
 public ArquivoItemGridVM(SimuladorGeoArquivo arquivo, eSimuladorGeoSituacao situacao = eSimuladorGeoSituacao.EmElaboracao)
 {
     if (situacao != eSimuladorGeoSituacao.Finalizado)
     {
         this.MostrarReenviar    = true;
         this.MostrarReprocessar = true;
         this.MostrarGerar       = true;
     }
 }
Example #6
0
        public ArquivoItemGridVM(SimuladorGeoArquivo arquivo, int ArquivoEnviadoTipo, eSimuladorGeoSituacao situacao = eSimuladorGeoSituacao.EmElaboracao)
        {
            this.ArquivoEnviadoTipo   = ArquivoEnviadoTipo;
            this.ArquivoProcessamento = arquivo;
            this.RegraBotoesGridVetoriais();

            if (situacao != eSimuladorGeoSituacao.Finalizado)
            {
                this.MostrarReenviar    = true;
                this.MostrarReprocessar = true;
                this.MostrarGerar       = true;
            }
        }
        internal int ExisteArquivoFila(SimuladorGeoArquivo arquivo, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                Comando comando = bancoDeDados.CriarComando(@"select t.id from {0}tab_fila t where t.projeto = :projeto and t.tipo = :tipo", EsquemaBancoPublicoGeo);

                comando.AdicionarParametroEntrada("projeto", arquivo.ProjetoId, DbType.Int32);
                comando.AdicionarParametroEntrada("tipo", arquivo.Tipo, DbType.Int32);

                object valor = bancoDeDados.ExecutarScalar(comando);

                return((valor != null && !Convert.IsDBNull(valor)) ? Convert.ToInt32(valor) : 0);
            }
        }
Example #8
0
 public void ObterSituacaoFila(SimuladorGeoArquivo arquivo)
 {
     try
     {
         using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(UsuarioPublicoGeo))
         {
             _da.ObterSituacaoFila(arquivo, bancoDeDados);
         }
     }
     catch (Exception exc)
     {
         Validacao.AddErro(exc);
     }
 }
Example #9
0
        public void CancelarProcessamento(SimuladorGeoArquivo arquivo)
        {
            try
            {
                arquivo.Etapa     = (int)eSimuladorGeoFilaEtapa.Validacao;
                arquivo.Situacao  = (int)eSimuladorGeoFilaSituacao.Cancelado;
                arquivo.Tipo      = (int)eSimuladorGeoFilaTipo.Dominialidade;
                arquivo.Mecanismo = (int)eSimuladorGeoMecanismo.Simulador;

                using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(UsuarioPublicoGeo))
                {
                    _da.AlterarSituacaoFila(arquivo, bancoDeDados);
                }

                ObterSituacao(arquivo);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }
        }
Example #10
0
        private void CarregarArquivosProcessados(SimuladorGeoVM vm)
        {
            if (vm.SimuladorGeo == null || vm.SimuladorGeo.Arquivos == null || vm.SimuladorGeo.Arquivos.Count == 0)
            {
                return;
            }

            if (vm.SimuladorGeo.Arquivos.Exists(x => x.Tipo == (int)eSimuladorGeoArquivoTipo.DadosGEOBASES))
            {
                vm.ArquivosVetoriais.RemoveAll(x => x.Tipo == (int)eSimuladorGeoArquivoTipo.DadosGEOBASES);
                vm.ArquivosVetoriais.Add(new ArquivoItemGridVM(vm.SimuladorGeo.Arquivos.Single(x => x.Tipo == (int)eSimuladorGeoArquivoTipo.DadosGEOBASES)));
            }

            #region Arquivos processados desse projeto

            List <SimuladorGeoArquivo> arquivos = vm.SimuladorGeo.Arquivos.Where(x =>
                                                                                 x.Tipo != (int)eSimuladorGeoArquivoTipo.DadosIDAF &&
                                                                                 x.Tipo != (int)eSimuladorGeoArquivoTipo.DadosGEOBASES &&
                                                                                 x.Tipo != (int)eSimuladorGeoArquivoTipo.CroquiFinal).ToList();

            if (arquivos != null && arquivos.Count > 0)
            {
                foreach (SimuladorGeoArquivo item in arquivos)
                {
                    if (item.Tipo == (int)eSimuladorGeoArquivoTipo.ArquivoEnviado && item.Situacao <= 0)
                    {
                        SimuladorGeoArquivo arquivoAux = arquivos.FirstOrDefault(x => x.Tipo == 4);
                        if (arquivoAux != null && arquivoAux.Id > 0)
                        {
                            item.Situacao      = arquivoAux.Situacao;
                            item.SituacaoTexto = arquivoAux.SituacaoTexto;
                        }
                    }

                    vm.ArquivosProcessados.Add(new ArquivoItemGridVM(item, vm.ArquivoEnviado.Tipo, (eSimuladorGeoSituacao)vm.SimuladorGeo.SituacaoId));
                }
            }

            #endregion
        }
        internal void ObterSituacaoFila(SimuladorGeoArquivo arquivo, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                Comando comando = bancoDeDados.CriarComando(@"select lc.id, lc.texto, cpg.arquivo, t.tipo from {1}tab_fila t, {0}lov_crt_projeto_geo_sit_proce lc, {0}tmp_projeto_geo_arquivos cpg
				where t.situacao = lc.situacao(+) and t.etapa = lc.etapa(+) and t.projeto = cpg.projeto(+) and t.tipo = cpg.tipo(+) and t.id = :arquivo_id"                , EsquemaBanco, EsquemaBancoPublicoGeo);

                comando.AdicionarParametroEntrada("arquivo_id", arquivo.IdRelacionamento, DbType.Int32);

                using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
                {
                    if (reader.Read())
                    {
                        if (reader["id"] != null && !Convert.IsDBNull(reader["id"]))
                        {
                            arquivo.Situacao = Convert.ToInt32(reader["id"]);
                        }

                        if (reader["tipo"] != null && !Convert.IsDBNull(reader["tipo"]))
                        {
                            arquivo.Tipo = Convert.ToInt32(reader["tipo"]);
                        }

                        if (reader["texto"] != null && !Convert.IsDBNull(reader["texto"]))
                        {
                            arquivo.SituacaoTexto = reader["texto"].ToString();
                        }

                        if (reader["arquivo"] != null && !Convert.IsDBNull(reader["arquivo"]))
                        {
                            arquivo.Id = Convert.ToInt32(reader["arquivo"]);
                        }
                    }
                    reader.Close();
                }
            }
        }
        internal void AlterarSituacaoFila(SimuladorGeoArquivo arquivo, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();

                Comando comando = bancoDeDados.CriarComando("begin update {1}tmp_projeto_geo tt set tt.mecanismo_elaboracao = :mecanismo where tt.id = :projeto;" +
                                                            "update {0}tab_fila t set t.etapa = :etapa, t.situacao = :situacao, t.data_fila = sysdate, t.data_inicio = null, t.data_fim = null, t.mecanismo_elaboracao = :mecanismo " +
                                                            "where t.projeto = :projeto and t.tipo = :tipo returning t.id into :id; end;", EsquemaBancoPublicoGeo, EsquemaBanco);

                comando.AdicionarParametroEntrada("projeto", arquivo.ProjetoId, DbType.Int32);
                comando.AdicionarParametroEntrada("tipo", arquivo.Tipo, DbType.Int32);
                comando.AdicionarParametroEntrada("mecanismo", arquivo.Mecanismo, DbType.Int32);
                comando.AdicionarParametroEntrada("etapa", arquivo.Etapa, DbType.Int32);
                comando.AdicionarParametroEntrada("situacao", arquivo.Situacao, DbType.Int32);
                comando.AdicionarParametroSaida("id", DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                arquivo.IdRelacionamento = Convert.ToInt32(comando.ObterValorParametro("id"));

                bancoDeDados.Commit();
            }
        }
        internal void AtualizarArquivosImportar(SimuladorGeoArquivo arquivoEnviado, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                Comando comando = bancoDeDados.CriarComando(@"
				update {0}tmp_projeto_geo_arquivos a set a.valido = 0, a.tid = :tid 
				where a.tipo > 3 and a.projeto = :projeto"                , EsquemaBanco);

                comando.AdicionarParametroEntrada("projeto", arquivoEnviado.ProjetoId, DbType.Int32);
                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                bancoDeDados.ExecutarNonQuery(comando);

                comando = bancoDeDados.CriarComando(@"
				update {0}tmp_projeto_geo_arquivos a set a.valido = 1, a.arquivo = :arquivo, a.tid = :tid 
				where a.projeto = :projeto and a.tipo = :tipo"                , EsquemaBanco);

                comando.AdicionarParametroEntrada("projeto", arquivoEnviado.ProjetoId, DbType.Int32);
                comando.AdicionarParametroEntrada("tipo", arquivoEnviado.Tipo, DbType.Int32);
                comando.AdicionarParametroEntrada("arquivo", arquivoEnviado.Id, DbType.Int32);
                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                bancoDeDados.ExecutarNonQuery(comando);

                if (comando.LinhasAfetadas == 0 && arquivoEnviado.Id > 0)
                {
                    comando = bancoDeDados.CriarComando(@"
					insert into {0}tmp_projeto_geo_arquivos (id, projeto, tipo, arquivo, valido, tid) values
					({0}seq_tmp_projeto_geo_arquivos.nextval, :projeto, 3, :arquivo, 1, :tid)"                    , EsquemaBanco);

                    comando.AdicionarParametroEntrada("projeto", arquivoEnviado.ProjetoId, DbType.Int32);
                    comando.AdicionarParametroEntrada("arquivo", arquivoEnviado.Id, DbType.Int32);
                    comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                    bancoDeDados.ExecutarNonQuery(comando);
                }
            }
        }
Example #14
0
 public ArquivoItemGridVM(SimuladorGeoArquivo arquivo)
 {
     this.ArquivoProcessamento = arquivo;
     this.RegraBotoesGridVetoriais();
 }
Example #15
0
        public SimuladorGeoArquivo EnviarArquivo(SimuladorGeo projeto)
        {
            SimuladorGeoArquivo arquivoEnviado = new SimuladorGeoArquivo();

            try
            {
                if (!_validar.EnviarArquivo(projeto))
                {
                    return(new SimuladorGeoArquivo());
                }

                arquivoEnviado           = projeto.ArquivoEnviado;
                arquivoEnviado.Tipo      = (int)eSimuladorGeoFilaTipo.Dominialidade;
                arquivoEnviado.Etapa     = (int)eSimuladorGeoFilaEtapa.Validacao;
                arquivoEnviado.Situacao  = (int)eSimuladorGeoFilaSituacao.Aguardando;
                arquivoEnviado.Mecanismo = (int)eSimuladorGeoMecanismo.Simulador;

                GerenciadorTransacao.ObterIDAtual();
                SimuladorGeoArquivoBus busArquivo = new SimuladorGeoArquivoBus();

                using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(UsuarioPublicoGeo))
                {
                    bancoDeDados.IniciarTransacao();

                    busArquivo.Copiar(arquivoEnviado);

                    busArquivo.ObterTemporario(arquivoEnviado);

                    arquivoEnviado.IdRelacionamento = _da.ExisteArquivoFila(arquivoEnviado, bancoDeDados);

                    List <SimuladorGeoArquivo> arquivosSalvos = _da.ObterArquivos(arquivoEnviado.ProjetoId, bancoDeDados)
                                                                .Where(x => x.Tipo == (int)eSimuladorGeoArquivoTipo.ArquivoEnviado).ToList();

                    Arquivo arqAnterior = null;

                    if (arquivosSalvos.Count > 0)
                    {
                        SimuladorGeoArquivo arq = arquivosSalvos.FirstOrDefault(x => x.Tipo == (int)eSimuladorGeoArquivoTipo.ArquivoEnviado);
                        try
                        {
                            arqAnterior = busArquivo.Obter((arq ?? new SimuladorGeoArquivo()).Id.GetValueOrDefault());
                            if (arqAnterior != null)
                            {
                                arquivoEnviado.Id = arqAnterior.Id.Value;
                                busArquivo.Deletar(arqAnterior.Caminho);
                            }
                        }
                        catch
                        {
                            ArquivoDa arqDa = new ArquivoDa();
                            if (arqAnterior == null && (arq ?? new SimuladorGeoArquivo()).Id.GetValueOrDefault() > 0)
                            {
                                arqAnterior = busArquivo.ObterDados((arq ?? new SimuladorGeoArquivo()).Id.GetValueOrDefault());
                            }
                            arqDa.MarcarDeletado(arqAnterior.Id.Value, arqAnterior.Caminho, bancoDeDados);
                        }
                    }

                    ArquivoDa _arquivoDa = new ArquivoDa();
                    _arquivoDa.Salvar(arquivoEnviado, null, "PublicoGeo", "PublicoGeo", (int)eExecutorTipo.Publico, null, bancoDeDados);

                    arquivoEnviado.Buffer.Close();
                    arquivoEnviado.Buffer.Dispose();
                    arquivoEnviado.Buffer = null;

                    projeto.MenorX = (projeto.EastingDecimal > 0) ? projeto.EastingDecimal - 5000 : Decimal.Zero;
                    projeto.MenorY = (projeto.NorthingDecimal > 0) ? projeto.NorthingDecimal - 5000 : Decimal.Zero;
                    projeto.MaiorX = (projeto.EastingDecimal > 0) ? projeto.EastingDecimal + 5000 : Decimal.Zero;
                    projeto.MaiorY = (projeto.NorthingDecimal > 0) ? projeto.NorthingDecimal + 5000 : Decimal.Zero;

                    _da.Salvar(projeto, bancoDeDados);

                    //Atualiza a lista de arquivos do projeto
                    _da.AtualizarArquivosImportar(arquivoEnviado, bancoDeDados);

                    if (arquivoEnviado.IdRelacionamento <= 0)
                    {
                        _da.InserirFila(arquivoEnviado, bancoDeDados);
                    }
                    else
                    {
                        _da.AlterarSituacaoFila(arquivoEnviado, bancoDeDados);
                    }

                    _da.AtualizarGeoEmp(projeto, bancoDeDados);

                    bancoDeDados.Commit();
                }

                ObterSituacao(arquivoEnviado);
            }
            catch (Exception exc)
            {
                if (arquivoEnviado != null && arquivoEnviado.Buffer != null)
                {
                    arquivoEnviado.Buffer.Close();
                    arquivoEnviado.Buffer.Dispose();
                    arquivoEnviado.Buffer = null;
                }

                Validacao.AddErro(exc);
            }
            return(arquivoEnviado);
        }