public ActionResult Visualizar(int id)
        {
            if (!_validar.Acessar(id))
            {
                return(RedirectToAction("", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() }));
            }

            SilviculturaATV caracterizacao = _bus.ObterPorEmpreendimento(id);
            string          textoMerge     = _caracterizacaoValidar.DependenciasAlteradas(
                caracterizacao.EmpreendimentoId,
                (int)eCaracterizacao.SilviculturaATV,
                eCaracterizacaoDependenciaTipo.Caracterizacao,
                caracterizacao.Dependencias, true);

            if (!string.IsNullOrEmpty(textoMerge))
            {
                caracterizacao = _bus.MergiarGeo(caracterizacao);
            }

            SilviculturaATVVM vm = new SilviculturaATVVM(caracterizacao, _listaBus.SilviculturaAtvCoberturaExitente, _listaBus.CaracterizacaoGeometriaTipo, _listaBus.SilviculturaAtvCaracteristicaFomento, true);

            vm.TextoMerge = textoMerge;
            vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
            vm.TextoAbrirModal = _validar.AbrirModalAcessar(caracterizacao);

            vm.TemARL             = true;
            vm.TemARLDesconhecida = false;

            return(View(vm));
        }
        internal bool Salvar(SilviculturaATV caracterizacao)
        {
            if (!_caracterizacaoValidar.Basicas(caracterizacao.EmpreendimentoId))
            {
                return(false);
            }

            if (caracterizacao.Id <= 0 && (_da.ObterPorEmpreendimento(caracterizacao.EmpreendimentoId, true) ?? new SilviculturaATV()).Id > 0)
            {
                Validacao.Add(Mensagem.Caracterizacao.EmpreendimentoCaracterizacaoJaCriada);
                return(false);
            }

            if (!Acessar(caracterizacao.EmpreendimentoId))
            {
                return(false);
            }

            if (caracterizacao.Areas.Exists(x => x.Tipo == (int)eSilviculturaAreaATV.DECLIVIDADE && (x.Valor == 0)))
            {
                Validacao.Add(Mensagem.SilviculturaAtvMsg.AreaDeclividadeObrigatoria);
            }

            #region Caracteristicas

            foreach (var item in caracterizacao.Caracteristicas)
            {
                if (item.Fomento == eFomentoTipoATV.Nulo)
                {
                    this.AddFormarMsg(Mensagem.SilviculturaAtvMsg.SelecioneFomento, item.Identificacao);
                }

                if (!item.DeclividadeToDecimal.HasValue || item.DeclividadeToDecimal.GetValueOrDefault(0) == 0)
                {
                    this.AddFormarMsg(Mensagem.SilviculturaAtvMsg.DeclividadeObrigatoria, item.Identificacao);
                }

                if (!item.TotalRequeridaToDecimal.HasValue || item.TotalRequeridaToDecimal.GetValueOrDefault(0) == 0)
                {
                    this.AddFormarMsg(Mensagem.SilviculturaAtvMsg.TotalRequeridaObrigatoria, item.Identificacao);
                }

                if (!item.TotalPlantadaComEucaliptoToDecimal.HasValue || item.TotalPlantadaComEucaliptoToDecimal.GetValueOrDefault(0) == 0)
                {
                    this.AddFormarMsg(Mensagem.SilviculturaAtvMsg.TotalPlantadaComEucaliptoObrigatoria, item.Identificacao);
                }

                if (item.Culturas.Count <= 0)
                {
                    Validacao.Add(Mensagem.SilviculturaAtvMsg.CulturaObrigatorio);
                }
            }

            #endregion

            return(Validacao.EhValido);
        }
Ejemplo n.º 3
0
        public SilviculturaATVVM(SilviculturaATV caracterizacao, List <Lista> tipoCobertura, List <Lista> tipoGeometria, List <Lista> tipoFomento, bool isVisualizar = false)
        {
            IsVisualizar   = isVisualizar;
            Caracterizacao = caracterizacao;

            foreach (var silvicultura in caracterizacao.Caracteristicas)
            {
                SilviculturaATVCaracteristicaVM queimaVM = new SilviculturaATVCaracteristicaVM(silvicultura, tipoCobertura, tipoGeometria, tipoFomento, isVisualizar);
                SilviculturaCaracteristicaVM.Add(queimaVM);
            }
        }
        public ActionResult GeoMergiar(SilviculturaATV silvicultura)
        {
            SilviculturaATVVM vm = new SilviculturaATVVM(_bus.MergiarGeo(silvicultura), _listaBus.SilviculturaAtvCoberturaExitente, _listaBus.CaracterizacaoGeometriaTipo, _listaBus.SilviculturaAtvCaracteristicaFomento);

            return(Json(new
            {
                @EhValido = Validacao.EhValido,
                @Msg = Validacao.Erros,
                @Html = ViewModelHelper.RenderPartialViewToString(ControllerContext, "SilviculturaATV", vm),
                @Dependencias = ViewModelHelper.Json(vm.Caracterizacao.Dependencias)
            }, JsonRequestBehavior.AllowGet));
        }
        public ActionResult Editar(int id)
        {
            if (!_caracterizacaoValidar.Basicas(id))
            {
                return(RedirectToAction("Index", "../Empreendimento", Validacao.QueryParamSerializer()));
            }

            if (!_validar.Acessar(id))
            {
                return(RedirectToAction("", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() }));
            }

            SilviculturaATV caracterizacao = _bus.ObterPorEmpreendimento(id);
            string          textoMerge     = _caracterizacaoValidar.DependenciasAlteradas(
                caracterizacao.EmpreendimentoId,
                (int)eCaracterizacao.SilviculturaATV,
                eCaracterizacaoDependenciaTipo.Caracterizacao,
                caracterizacao.Dependencias);

            if (!string.IsNullOrEmpty(textoMerge))
            {
                caracterizacao = _bus.MergiarGeo(caracterizacao);
            }

            SilviculturaATVVM vm = new SilviculturaATVVM(caracterizacao, _listaBus.SilviculturaAtvCoberturaExitente, _listaBus.CaracterizacaoGeometriaTipo, _listaBus.SilviculturaAtvCaracteristicaFomento);

            vm.TextoMerge = textoMerge;
            vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
            vm.TextoAbrirModal = _validar.AbrirModalAcessar(caracterizacao);

            var emp         = _empBus.Obter(id);
            var enderecoEmp = emp.Enderecos.Find(x => x.ZonaLocalizacaoId == (int)eEmpreendimentoLocalizacao.ZonaRural);

            if (enderecoEmp != null)
            {
                if (!string.IsNullOrEmpty(textoMerge))
                {
                    vm.TemARL             = _bus.TemARL(id);
                    vm.TemARLDesconhecida = _bus.TemARLDesconhecida(id);
                }
            }
            else
            {
                vm.TemARL             = true;
                vm.TemARLDesconhecida = false;
            }

            return(View(vm));
        }
Ejemplo n.º 6
0
        internal void Salvar(SilviculturaATV caracterizacao, BancoDeDados banco)
        {
            if (caracterizacao == null)
            {
                throw new Exception("A Caracterização é nula.");
            }

            if (caracterizacao.Id <= 0)
            {
                Criar(caracterizacao, banco);
            }
            else
            {
                Editar(caracterizacao, banco);
            }
        }
Ejemplo n.º 7
0
        public SilviculturaATV ObterPorEmpreendimento(int EmpreendimentoId, bool simplificado = false, BancoDeDados banco = null)
        {
            SilviculturaATV caracterizacao = null;

            try
            {
                caracterizacao = _da.ObterPorEmpreendimento(EmpreendimentoId, simplificado: simplificado);
                caracterizacao.Dependencias = _busCaracterizacao.ObterDependencias(caracterizacao.Id, eCaracterizacao.SilviculturaATV, eCaracterizacaoDependenciaTipo.Caracterizacao);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(caracterizacao);
        }
Ejemplo n.º 8
0
        internal SilviculturaATV ObterPorEmpreendimento(int empreendimento, bool simplificado = false, BancoDeDados banco = null)
        {
            SilviculturaATV caracterizacao = new SilviculturaATV();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                Comando comando = bancoDeDados.CriarComando(@"select s.id from {0}crt_silvicultura_atv s where s.empreendimento = :empreendimento", EsquemaBanco);
                comando.AdicionarParametroEntrada("empreendimento", empreendimento, DbType.Int32);

                object valor = bancoDeDados.ExecutarScalar(comando);

                if (valor != null && !Convert.IsDBNull(valor))
                {
                    caracterizacao = Obter(Convert.ToInt32(valor), bancoDeDados, simplificado);
                }
            }

            return(caracterizacao);
        }
        public ActionResult Criar(int id)
        {
            if (!_caracterizacaoValidar.Basicas(id))
            {
                return(RedirectToAction("Index", "../Empreendimento", Validacao.QueryParamSerializer()));
            }

            SilviculturaATV caracterizacao = _bus.ObterDadosGeo(id);

            caracterizacao.EmpreendimentoId = id;

            if (!_validar.Acessar(caracterizacao.EmpreendimentoId))
            {
                return(RedirectToAction("", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() }));
            }

            caracterizacao.Dependencias = _caracterizacaoBus.ObterDependenciasAtual(id, eCaracterizacao.SilviculturaATV, eCaracterizacaoDependenciaTipo.Caracterizacao);
            SilviculturaATVVM vm = new SilviculturaATVVM(caracterizacao, _listaBus.SilviculturaAtvCoberturaExitente, _listaBus.CaracterizacaoGeometriaTipo, _listaBus.SilviculturaAtvCaracteristicaFomento);

            /*var areaTotal = vm.ObterArea(eSilviculturaAreaATV.AA_TOTAL_FLORESTA);
             * areaTotal.Valor = vm.ObterArea(eSilviculturaAreaATV.AVN).Valor + vm.ObterArea(eSilviculturaAreaATV.AA_FLORESTA_PLANTADA).Valor;
             * areaTotal.ValorTexto = areaTotal.Valor.ToStringTrunc();*/

            vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
            vm.TextoAbrirModal = _validar.AbrirModalAcessar(caracterizacao);

            var emp         = _empBus.Obter(id);
            var enderecoEmp = emp.Enderecos.Find(x => x.ZonaLocalizacaoId == (int)eEmpreendimentoLocalizacao.ZonaRural);

            if (enderecoEmp != null)
            {
                vm.TemARL             = _bus.TemARL(id);
                vm.TemARLDesconhecida = _bus.TemARLDesconhecida(id);
            }
            else
            {
                vm.TemARL             = true;
                vm.TemARLDesconhecida = false;
            }

            return(View(vm));
        }
        public string AbrirModalAcessar(SilviculturaATV caracterizacao)
        {
            EmpreendimentoCaracterizacao empreendimento = _caracterizacaoBus.ObterEmpreendimentoSimplificado(caracterizacao.EmpreendimentoId);

            /*if (empreendimento.ZonaLocalizacao == eZonaLocalizacao.Rural)
             * {
             *      DominialidadeDa dominialidadeDa = new DominialidadeDa();
             *      Dominialidade dominialidade = dominialidadeDa.ObterPorEmpreendimento(caracterizacao.EmpreendimentoId);
             *
             *      foreach (Dominio dominio in dominialidade.Dominios)
             *      {
             *              if (dominio.ReservasLegais.Exists(x => x.SituacaoId == (int)eReservaLegalSituacao.NaoInformada))
             *              {
             *                      return Mensagem.Silvicultura.EmpreendimentoRuralReservaIndefinida.Texto;
             *              }
             *      }
             * }*/

            return(string.Empty);
        }
        public ActionResult Criar(SilviculturaATV caracterizacao)
        {
            string textoMerge = _caracterizacaoValidar.DependenciasAlteradas(
                caracterizacao.EmpreendimentoId,
                (int)eCaracterizacao.SilviculturaATV,
                eCaracterizacaoDependenciaTipo.Caracterizacao,
                caracterizacao.Dependencias);

            if (!string.IsNullOrEmpty(textoMerge))
            {
                return(Json(new { @TextoMerge = textoMerge }, JsonRequestBehavior.AllowGet));
            }

            _bus.Salvar(caracterizacao);
            return(Json(new
            {
                @EhValido = Validacao.EhValido,
                @Msg = Validacao.Erros,
                @UrlRedirecionar = Url.Action("", "Caracterizacao", new { id = caracterizacao.EmpreendimentoId, Msg = Validacao.QueryParam() })
            }, JsonRequestBehavior.AllowGet));
        }
Ejemplo n.º 12
0
        internal SilviculturaATV Obter(int id, BancoDeDados banco = null, string tid = null, bool simplificado = false)
        {
            SilviculturaATV caracterizacao = new SilviculturaATV();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                if (tid == null)
                {
                    caracterizacao = Obter(id, bancoDeDados, simplificado);
                }
                else
                {
                    Comando comando = bancoDeDados.CriarComando(@"select count(s.id) existe from {0}crt_silvicultura s where s.id = :id and s.tid = :tid", EsquemaBanco);

                    comando.AdicionarParametroEntrada("id", id, DbType.Int32);
                    comando.AdicionarParametroEntrada("tid", DbType.String, 36, tid);

                    caracterizacao = (Convert.ToBoolean(bancoDeDados.ExecutarScalar(comando))) ? Obter(id, bancoDeDados, simplificado) : ObterHistorico(id, bancoDeDados, tid, simplificado);
                }
            }

            return(caracterizacao);
        }
Ejemplo n.º 13
0
        public SilviculturaATVPDF(SilviculturaATV caracterizacao)
        {
            if (caracterizacao.Areas.Count > 0)
            {
                AreaPlantioProprio = caracterizacao.Areas.FirstOrDefault(x => x.Tipo == (int)eSilviculturaAreaATV.AA_PLANTIO).ValorTexto;
                AreaOutroFomento   = caracterizacao.Areas.FirstOrDefault(x => x.Tipo == (int)eSilviculturaAreaATV.AA_FOMENTO).ValorTexto;
                DeclividadePredominantePropriedade = caracterizacao.Areas.FirstOrDefault(x => x.Tipo == (int)eSilviculturaAreaATV.DECLIVIDADE).ValorTexto;
            }

            DeclividadePredominanteDecimal = 0;
            TotalAreaRequeridaDecimal      = 0;
            TotalAreaCroquiDecimal         = 0;
            AreaPlantadaEucalipitoDecimal  = 0;

            foreach (SilviculturaCaracteristicaATV silvicultura in caracterizacao.Caracteristicas)
            {
                DeclividadePredominanteDecimal = (silvicultura.DeclividadeToDecimal.GetValueOrDefault(0) > DeclividadePredominanteDecimal) ? silvicultura.DeclividadeToDecimal.GetValueOrDefault(0) : DeclividadePredominanteDecimal;
                TotalAreaRequeridaDecimal     += silvicultura.TotalRequeridaToDecimal.GetValueOrDefault(0);
                TotalAreaCroquiDecimal        += silvicultura.TotalCroqui;
                AreaPlantadaEucalipitoDecimal += silvicultura.TotalPlantadaComEucaliptoToDecimal.GetValueOrDefault(0);
            }

            //Agrupando Culturas Florestais ATV
            List <CulturaFlorestalATV> culturas = new List <CulturaFlorestalATV>();

            caracterizacao.Caracteristicas.ForEach(x => { x.Culturas.ForEach(y => { culturas.Add(y); }); });
            culturas.ForEach(cultura =>
            {
                if (!Culturas.Exists(y => y.CulturaTipoTexto.ToLower() == cultura.CulturaTipoTexto.ToLower()))
                {
                    cultura.AreaCultura = culturas
                                          .Where(x => x.CulturaTipoTexto.ToLower() == cultura.CulturaTipoTexto.ToLower())
                                          .Sum(x => Convert.ToDecimal(x.AreaCultura)).ToString();
                    Culturas.Add(cultura);
                }
            });
        }
Ejemplo n.º 14
0
        public bool Salvar(SilviculturaATV caracterizacao)
        {
            try
            {
                if (_validar.Salvar(caracterizacao))
                {
                    GerenciadorTransacao.ObterIDAtual();

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

                        _da.Salvar(caracterizacao, bancoDeDados);

                        //Gerencia as dependências da caracterização
                        _busCaracterizacao.Dependencias(new Caracterizacao()
                        {
                            Id             = caracterizacao.Id,
                            Tipo           = eCaracterizacao.SilviculturaATV,
                            DependenteTipo = eCaracterizacaoDependenciaTipo.Caracterizacao,
                            Dependencias   = caracterizacao.Dependencias
                        }, bancoDeDados);

                        Validacao.Add(Mensagem.Silvicultura.Salvar);

                        bancoDeDados.Commit();
                    }
                }
            }
            catch (Exception e)
            {
                Validacao.AddErro(e);
            }

            return(Validacao.EhValido);
        }
Ejemplo n.º 15
0
        internal void Editar(SilviculturaATV caracterizacao, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Silvicultura - Implantação da Atividade de Silvicultura (Fomento)

                bancoDeDados.IniciarTransacao();

                Comando comando = bancoDeDados.CriarComando(@"update {0}crt_silvicultura c set c.tid = :tid where c.id = :id", EsquemaBanco);

                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                comando.AdicionarParametroEntrada("id", caracterizacao.Id, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                #endregion

                #region Limpar os dados do banco

                comando = bancoDeDados.CriarComando("delete from {0}crt_silvicultura_atv_cult t ", EsquemaBanco);
                comando.DbCommand.CommandText += String.Format("where t.caracterizacao = :caracterizacao{0}",
                                                               comando.AdicionarNotIn("and", "t.silvicultura_id", DbType.Int32, caracterizacao.Caracteristicas.Select(x => x.Id).ToList()));
                comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                foreach (var item in caracterizacao.Caracteristicas)
                {
                    comando = bancoDeDados.CriarComando("delete from {0}crt_silvicultura_atv_cult t ", EsquemaBanco);
                    comando.DbCommand.CommandText += String.Format("where t.silvicultura_id = :silvicultura_id{0}",
                                                                   comando.AdicionarNotIn("and", "t.id", DbType.Int32, item.Culturas.Select(x => x.Id).ToList()));
                    comando.AdicionarParametroEntrada("silvicultura_id", item.Id, DbType.Int32);

                    bancoDeDados.ExecutarNonQuery(comando);
                }

                comando = bancoDeDados.CriarComando("delete from {0}crt_silvicultura_atv_carac t ", EsquemaBanco);
                comando.DbCommand.CommandText += String.Format("where t.caracterizacao = :caracterizacao{0}",
                                                               comando.AdicionarNotIn("and", "t.id", DbType.Int32, caracterizacao.Caracteristicas.Select(x => x.Id).ToList()));
                comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                comando = bancoDeDados.CriarComando("delete from {0}crt_silvicultura_atv_areas c ", EsquemaBanco);
                comando.DbCommand.CommandText += String.Format("where c.caracterizacao = :caracterizacao{0}",
                                                               comando.AdicionarNotIn("and", "c.id", DbType.Int32, caracterizacao.Areas.Select(x => x.Id).ToList()));
                comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);
                bancoDeDados.ExecutarNonQuery(comando);

                #endregion

                #region Áreas

                foreach (SilviculturaAreaATV area in caracterizacao.Areas)
                {
                    if (area.Id > 0)
                    {
                        comando = bancoDeDados.CriarComando(@"
							update {0}crt_silvicultura_atv_areas c
							   set c.tipo = :tipo, 
								   c.valor = :valor, 
								   c.tid = :tid
							 where c.id = :id"                            , EsquemaBanco);

                        comando.AdicionarParametroEntrada("id", area.Id, DbType.Int32);
                    }
                    else
                    {
                        comando = bancoDeDados.CriarComando(@"
							insert into {0}crt_silvicultura_atv_areas
							  (id, 
							   caracterizacao, 
							   tipo, 
							   valor, 
							   tid)
							values
							  ({0}seq_crt_silvic_atv_areas.nextval,
							   :caracterizacao,
							   :tipo,
							   :valor,
							   :tid)"                            , EsquemaBanco);

                        comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);
                    }

                    comando.AdicionarParametroEntrada("tipo", area.Tipo, DbType.Int32);
                    comando.AdicionarParametroEntrada("valor", area.Valor, DbType.Decimal);
                    comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                    bancoDeDados.ExecutarNonQuery(comando);
                }

                #endregion

                #region Caracteristicas

                foreach (var item in caracterizacao.Caracteristicas)
                {
                    if (item.Id > 0)
                    {
                        comando = bancoDeDados.CriarComando(@"
								update {0}crt_silvicultura_atv_carac c
								   set c.identificacao         = :identificacao,
									   c.geometria             = :geometria,
									   c.fomento               = :fomento,
									   c.declividade           = :declividade,
									   c.total_requerida       = :total_requerida,
									   c.total_croqui          = :total_croqui,
									   c.total_plant_eucalipto = :total_plant_eucalipto,
									   c.tid                   = :tid
								 where c.id = :id"                                , EsquemaBanco);

                        comando.AdicionarParametroEntrada("id", item.Id, DbType.Int32);
                    }
                    else
                    {
                        comando = bancoDeDados.CriarComando(@"
								insert into {0}crt_silvicultura_atv_carac c
								  (id,
								   caracterizacao,
								   identificacao,
								   geometria,
								   fomento,
								   declividade,
								   total_requerida,
								   total_croqui,
								   total_plant_eucalipto,
								   tid)
								values
								  ({0}seq_crt_silvic_atv_carac.nextval,
								   :caracterizacao,
								   :identificacao,
								   :geometria,
								   :fomento,
								   :declividade,
								   :total_requerida,
								   :total_croqui,
								   :total_plant_eucalipto,
								   :tid)
								returning c.id into :id"                                , EsquemaBanco);

                        comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);
                        comando.AdicionarParametroSaida("id", DbType.Int32);
                    }

                    comando.AdicionarParametroEntrada("identificacao", item.Identificacao, DbType.String);
                    comando.AdicionarParametroEntrada("geometria", item.GeometriaTipo, DbType.Int32);
                    comando.AdicionarParametroEntrada("fomento", item.Fomento, DbType.Int32);
                    comando.AdicionarParametroEntrada("declividade", item.Declividade, DbType.Decimal);
                    comando.AdicionarParametroEntrada("total_requerida", item.TotalRequerida, DbType.Decimal);
                    comando.AdicionarParametroEntrada("total_croqui", item.TotalCroqui, DbType.Decimal);
                    comando.AdicionarParametroEntrada("total_plant_eucalipto", item.TotalPlantadaComEucalipto, DbType.Decimal);
                    comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                    bancoDeDados.ExecutarNonQuery(comando);

                    item.Id = item.Id > 0 ? item.Id : Convert.ToInt32(comando.ObterValorParametro("id"));

                    #region Culturas Florestais

                    foreach (CulturaFlorestalATV itemAux in item.Culturas)
                    {
                        if (itemAux.Id > 0)
                        {
                            comando = bancoDeDados.CriarComando(@"
								 update {0}crt_silvicultura_atv_cult c
									set c.caracterizacao  = :caracterizacao,
										c.silvicultura_id = :silvicultura_id,
										c.cultura         = :cultura,
										c.area            = :area,
										c.especificar     = :especificar,
										c.tid             = :tid
								  where c.id = :id"                                , EsquemaBanco);

                            comando.AdicionarParametroEntrada("id", itemAux.Id, DbType.Int32);
                        }
                        else
                        {
                            comando = bancoDeDados.CriarComando(@"
								insert into {0}crt_silvicultura_atv_cult c
									(id, 
									caracterizacao, 
									silvicultura_id, 
									cultura, 
									area, 
									especificar, 
									tid)
								values
									({0}seq_crt_silvic_atv_cult.nextval,
									:caracterizacao,
									:silvicultura_id,
									:cultura,
									:area,
									:especificar,
									:tid) returning id into :id"                                    , EsquemaBanco);

                            comando.AdicionarParametroSaida("id", DbType.Int32);
                        }

                        comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);
                        comando.AdicionarParametroEntrada("silvicultura_id", item.Id, DbType.Int32);
                        comando.AdicionarParametroEntrada("cultura", itemAux.CulturaTipo, DbType.Int32);
                        comando.AdicionarParametroEntrada("area", itemAux.AreaCultura, DbType.Decimal);
                        comando.AdicionarParametroEntrada("especificar", string.Empty, DbType.String);
                        comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                        bancoDeDados.ExecutarNonQuery(comando);

                        itemAux.Id = itemAux.Id > 0 ? itemAux.Id : Convert.ToInt32(comando.ObterValorParametro("id"));
                    }

                    #endregion
                }

                #endregion

                #region Histórico

                Historico.Gerar(caracterizacao.Id, eHistoricoArtefatoCaracterizacao.silviculturaatv, eHistoricoAcao.atualizar, bancoDeDados);

                #endregion

                bancoDeDados.Commit();
            }
        }
Ejemplo n.º 16
0
        public SilviculturaATV MergiarGeo(SilviculturaATV caracterizacaoAtual)
        {
            SilviculturaATV dadosGeo = ObterDadosGeo(caracterizacaoAtual.EmpreendimentoId);

            caracterizacaoAtual.Dependencias = _busCaracterizacao.ObterDependenciasAtual(caracterizacaoAtual.EmpreendimentoId, eCaracterizacao.SilviculturaATV, eCaracterizacaoDependenciaTipo.Caracterizacao);

            decimal totalFloresta = 0;

            caracterizacaoAtual.Areas.ForEach(x =>
            {
                if (x.Tipo != (int)eSilviculturaAreaATV.DECLIVIDADE &&
                    x.Tipo != (int)eSilviculturaAreaATV.AA_FOMENTO &&
                    x.Tipo != (int)eSilviculturaAreaATV.AA_PLANTIO)
                {
                    x.Valor      = dadosGeo.Areas.Find(z => z.Tipo == x.Tipo).Valor;
                    x.ValorTexto = x.Valor.ToStringTrunc();
                }

                if (x.Tipo == (int)eSilviculturaAreaATV.AVN ||
                    x.Tipo == (int)eSilviculturaAreaATV.AA_PLANTIO ||
                    x.Tipo == (int)eSilviculturaAreaATV.AA_FLORESTA_PLANTADA)
                {
                    totalFloresta += x.Valor;
                }
            });

            caracterizacaoAtual.Areas.Find(x => x.Tipo == (int)eSilviculturaAreaATV.AA_TOTAL_FLORESTA).Valor      = totalFloresta;
            caracterizacaoAtual.Areas.Find(x => x.Tipo == (int)eSilviculturaAreaATV.AA_TOTAL_FLORESTA).ValorTexto = totalFloresta.ToStringTrunc();

            foreach (SilviculturaCaracteristicaATV silvicultura in dadosGeo.Caracteristicas)
            {
                if (!caracterizacaoAtual.Caracteristicas.Exists(x => x.Identificacao == silvicultura.Identificacao))
                {
                    caracterizacaoAtual.Caracteristicas.Add(silvicultura);
                }
            }

            List <SilviculturaCaracteristicaATV> silviculturasRemover = new List <SilviculturaCaracteristicaATV>();

            foreach (SilviculturaCaracteristicaATV silvicultura in caracterizacaoAtual.Caracteristicas)
            {
                if (!dadosGeo.Caracteristicas.Exists(x => x.Identificacao == silvicultura.Identificacao))
                {
                    silviculturasRemover.Add(silvicultura);
                    continue;
                }
                else
                {
                    SilviculturaCaracteristicaATV silviculturaAux = dadosGeo.Caracteristicas.SingleOrDefault(x => x.Identificacao == silvicultura.Identificacao) ?? new SilviculturaCaracteristicaATV();
                    silvicultura.Identificacao = silviculturaAux.Identificacao;
                    silvicultura.TotalCroqui   = silviculturaAux.TotalCroqui;
                }
            }

            foreach (SilviculturaCaracteristicaATV silvicultura in silviculturasRemover)
            {
                caracterizacaoAtual.Caracteristicas.Remove(silvicultura);
            }

            return(caracterizacaoAtual);
        }
Ejemplo n.º 17
0
        internal SilviculturaATV Obter(int id, BancoDeDados banco = null, bool simplificado = false)
        {
            SilviculturaATV caracterizacao = new SilviculturaATV();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Silvicultura - Implantação da Atividade de Silvicultura (Fomento)

                Comando comando = bancoDeDados.CriarComando(@"select c.id Id, c.empreendimento EmpreendimentoId, c.tid Tid from {0}crt_silvicultura_atv c where c.id = :id", EsquemaBanco);

                comando.AdicionarParametroEntrada("id", id, DbType.Int32);

                caracterizacao = bancoDeDados.ObterEntity <SilviculturaATV>(comando);

                #endregion

                if (simplificado)
                {
                    return(caracterizacao);
                }

                #region Áreas

                comando = bancoDeDados.CriarComando(@"
					select a.id         Id,
						   la.id       Tipo,
						   la.texto     TipoTexto,
						   a.valor      Valor,
						   a.tid        Tid,
						   la.descricao Descricao
					  from crt_silvicultura_atv_areas a, 
						   lov_crt_silvic_atv_area la
					 where la.id = a.tipo(+)
					   and :caracterizacao = a.caracterizacao(+)"                    , EsquemaBanco);

                comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);

                caracterizacao.Areas = bancoDeDados.ObterEntityList <SilviculturaAreaATV>(comando, (IDataReader reader, SilviculturaAreaATV item) =>
                {
                    item.Valor      = reader.GetValue <Decimal>("Valor");
                    item.ValorTexto = reader.GetValue <Decimal>("Valor").ToStringTrunc();
                });

                #endregion

                #region Caracteriscas

                comando = bancoDeDados.CriarComando(@"
					select c.id Id,
						   c.tid Tid,
						   c.identificacao Identificacao,
						   lv.id GeometriaTipo,
						   lv.texto GeometriaTipoTexto,
						   c.fomento FomentoId,
						   c.declividade Declividade,
						   c.total_requerida TotalRequerida,
						   c.total_croqui TotalCroqui,
						   c.total_plant_eucalipto TotalPlantadaComEucalipto
					  from {0}crt_silvicultura_atv_carac c, 
						   {0}lov_crt_geometria_tipo lv,
						   {0}lov_crt_silvic_atv_fomento lf
					 where c.caracterizacao = :id
					   and c.geometria = lv.id(+)
					   and c.fomento = lf.id(+)
					 order by c.id"                    , EsquemaBanco);

                comando.AdicionarParametroEntrada("id", id, DbType.Int32);

                caracterizacao.Caracteristicas = bancoDeDados.ObterEntityList <SilviculturaCaracteristicaATV>(comando);

                #region Culturas Florestais

                foreach (var item in caracterizacao.Caracteristicas)
                {
                    comando = bancoDeDados.CriarComando(@"
						select c.id Id,
							   lc.id CulturaTipo,
							   lc.texto CulturaTipoTexto,
							   c.area AreaCultura,
							   c.especificar EspecificarTexto,
							   c.tid Tid
						  from {0}crt_silvicultura_atv_cult c, 
							   {0}lov_crt_silvic_atv_cobe lc
						 where c.cultura = lc.id
						   and c.silvicultura_id = :silvicultura"                        , EsquemaBanco);

                    comando.AdicionarParametroEntrada("silvicultura", item.Id, DbType.Int32);

                    item.Culturas = bancoDeDados.ObterEntityList <CulturaFlorestalATV>(comando);
                }

                #endregion

                #endregion
            }

            return(caracterizacao);
        }
Ejemplo n.º 18
0
        private SilviculturaATV ObterHistorico(int id, BancoDeDados banco = null, string tid = null, bool simplificado = false)
        {
            SilviculturaATV caracterizacao    = new SilviculturaATV();
            int             hst               = 0;
            int             hstCaracterizacao = 0;

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Silvicultura - Implantação da Atividade de Silvicultura (Fomento)

                Comando comando = bancoDeDados.CriarComando(@"
					select c.caracterizacao Id, 
						   c.empreendimento_id EmpreendimentoId, 
						   c.tid Tid,
						   c.id hstId
					  from {0}hst_crt_silvicultura_atv c
					 where c.caracterizacao = :id
					   and c.tid = :tid"                    , EsquemaBanco);

                comando.AdicionarParametroEntrada("id", id, DbType.Int32);
                comando.AdicionarParametroEntrada("tid", DbType.String, 36, tid);

                caracterizacao    = bancoDeDados.ObterEntity <SilviculturaATV>(comando, (IDataReader reader, SilviculturaATV item) => { hst = reader.GetValue <int>("hstId"); });
                hstCaracterizacao = hst;

                #endregion

                if (simplificado)
                {
                    return(caracterizacao);
                }

                #region Áreas

                comando = bancoDeDados.CriarComando(@"
					select a.silvicultura_area_id Id, 
						   a.tipo_id Tipo, 
						   a.tipo_texto TipoTexto, 
						   a.valor Valor, 
						   a.tid Tid,
						   la.descricao Descricao
					  from {0}hst_crt_silvic_atv_areas a,
					       {0}lov_crt_silvic_atv_area la 
					 where la.id = a.tipo_id(+)
					   and a.id_hst = :hst_caracterizacao"                    , EsquemaBanco);

                comando.AdicionarParametroEntrada("hst_caracterizacao", hstCaracterizacao, DbType.Int32);

                caracterizacao.Areas = bancoDeDados.ObterEntityList <SilviculturaAreaATV>(comando, (IDataReader reader, SilviculturaAreaATV item) =>
                {
                    item.Valor      = reader.GetValue <Decimal>("Valor");
                    item.ValorTexto = reader.GetValue <Decimal>("Valor").ToStringTrunc();
                });

                #endregion

                #region Caracteristicas

                comando = bancoDeDados.CriarComando(@"
					select c.id hstId,
						   c.silvicultura_silv_id Id,
						   c.identificacao Identificacao,
						   c.geometria_id GeometriaTipo,
						   c.geometria_texto GeometriaTipoTexto,
						   c.fomento_id Fomento,
						   c.declividade Declividade,
						   c.total_requerida TotalRequerida,
						   c.total_croqui TotalCroqui,
						   c.total_plant_eucalipto TotalPlantadaComEucalipto,       
						   c.tid Tid       
					  from {0}hst_crt_silvic_atv_carac c
					 where c.id_hst = :id"                    , EsquemaBanco);

                comando.AdicionarParametroEntrada("id", hst, DbType.Int32);

                caracterizacao.Caracteristicas = bancoDeDados.ObterEntityList <SilviculturaCaracteristicaATV>(comando, (IDataReader reader, SilviculturaCaracteristicaATV item) =>
                {
                    #region Culturas Florestais
                    hst     = reader.GetValue <int>("hstId");
                    comando = bancoDeDados.CriarComando(@"
							select c.silvicultura_cult_id Id,
								   c.cultura_id CulturaTipo,
								   c.cultura_texto CulturaTipoTexto,
								   c.area AreaCultura,
								   c.especificar EspecificarTexto,
								   c.tid Tid
							  from {0}hst_crt_silvic_atv_cult c
							 where c.id_hst = :id"                            , EsquemaBanco);

                    comando.AdicionarParametroEntrada("id", hst, DbType.Int32);
                    item.Culturas = bancoDeDados.ObterEntityList <CulturaFlorestalATV>(comando);
                    #endregion
                });

                #endregion
            }

            return(caracterizacao);
        }
Ejemplo n.º 19
0
        internal int?Criar(SilviculturaATV caracterizacao, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Silvicultura - Implantação da Atividade de Silvicultura (Fomento)

                bancoDeDados.IniciarTransacao();

                Comando comando = bancoDeDados.CriarComando(@"
					insert into {0}crt_silvicultura_atv c
					  (id, 
					   empreendimento, 
					   tid)
					values
					  ({0}seq_crt_silvicultura_atv.nextval, 
					   :empreendimento, 
					   :tid)
					returning c.id into :id"                    , EsquemaBanco);

                comando.AdicionarParametroEntrada("empreendimento", caracterizacao.EmpreendimentoId, DbType.Int32);
                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                comando.AdicionarParametroSaida("id", DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                caracterizacao.Id = Convert.ToInt32(comando.ObterValorParametro("id"));

                #endregion

                #region Silvicultura/Áreas

                if (caracterizacao.Areas != null && caracterizacao.Areas.Count > 0)
                {
                    foreach (var area in caracterizacao.Areas)
                    {
                        comando = bancoDeDados.CriarComando(@"
							insert into {0}crt_silvicultura_atv_areas
							  (id, 
							   caracterizacao, 
							   tipo, 
							   valor, 
							   tid)
							values
							  ({0}seq_crt_silvic_atv_areas.nextval,
							   :caracterizacao,
							   :tipo,
							   :valor,
							   :tid)"                            , EsquemaBanco);

                        comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);
                        comando.AdicionarParametroEntrada("tipo", area.Tipo, DbType.Int32);
                        comando.AdicionarParametroEntrada("valor", area.Valor, DbType.Decimal);
                        comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                        bancoDeDados.ExecutarNonQuery(comando);
                    }
                }

                #endregion

                #region Silvicultura/Caracteristicas

                if (caracterizacao.Caracteristicas != null && caracterizacao.Caracteristicas.Count > 0)
                {
                    foreach (var item in caracterizacao.Caracteristicas)
                    {
                        comando = bancoDeDados.CriarComando(@"
							insert into {0}crt_silvicultura_atv_carac c
							  (id,
							   caracterizacao,
							   identificacao,
							   geometria,
							   fomento,
							   declividade,
							   total_requerida,
							   total_croqui,
							   total_plant_eucalipto,
							   tid)
							values
							  ({0}seq_crt_silvic_atv_carac.nextval,
							   :caracterizacao,
							   :identificacao,
							   :geometria,
							   :fomento,
							   :declividade,
							   :total_requerida,
							   :total_croqui,
							   :total_plant_eucalipto,
							   :tid)
							returning c.id into :id"                            , EsquemaBanco);

                        comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);
                        comando.AdicionarParametroEntrada("identificacao", item.Identificacao, DbType.String);
                        comando.AdicionarParametroEntrada("geometria", item.GeometriaTipo, DbType.Int32);
                        comando.AdicionarParametroEntrada("fomento", item.Fomento, DbType.Int32);
                        comando.AdicionarParametroEntrada("declividade", item.Declividade, DbType.Decimal);
                        comando.AdicionarParametroEntrada("total_requerida", item.TotalRequerida, DbType.Decimal);
                        comando.AdicionarParametroEntrada("total_croqui", item.TotalCroqui, DbType.Decimal);
                        comando.AdicionarParametroEntrada("total_plant_eucalipto", item.TotalPlantadaComEucalipto, DbType.Decimal);
                        comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                        comando.AdicionarParametroSaida("id", DbType.Int32);

                        bancoDeDados.ExecutarNonQuery(comando);

                        item.Id = Convert.ToInt32(comando.ObterValorParametro("id"));

                        #region Culturas Florestais

                        if (item.Culturas != null && item.Culturas.Count > 0)
                        {
                            foreach (CulturaFlorestalATV itemAux in item.Culturas)
                            {
                                comando = bancoDeDados.CriarComando(@"
									insert into {0}crt_silvicultura_atv_cult c
									  (id, 
									   caracterizacao, 
									   silvicultura_id, 
									   cultura, 
									   area, 
									   especificar, 
									   tid)
									values
									  ({0}seq_crt_silvic_atv_cult.nextval,
									   :caracterizacao,
									   :silvicultura_id,
									   :cultura,
									   :area,
									   :especificar,
									   :tid)"                                    , EsquemaBanco);

                                comando.AdicionarParametroEntrada("caracterizacao", caracterizacao.Id, DbType.Int32);
                                comando.AdicionarParametroEntrada("silvicultura_id", item.Id, DbType.Int32);
                                comando.AdicionarParametroEntrada("cultura", itemAux.CulturaTipo, DbType.Int32);
                                comando.AdicionarParametroEntrada("area", itemAux.AreaCultura, DbType.Decimal);
                                comando.AdicionarParametroEntrada("especificar", String.Empty, DbType.String);
                                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());

                                bancoDeDados.ExecutarNonQuery(comando);
                            }
                        }

                        #endregion
                    }
                }

                #endregion

                #region Histórico

                Historico.Gerar(caracterizacao.Id, eHistoricoArtefatoCaracterizacao.silviculturaatv, eHistoricoAcao.criar, bancoDeDados);

                #endregion

                bancoDeDados.Commit();

                return(caracterizacao.Id);
            }
        }
Ejemplo n.º 20
0
        internal SilviculturaATV ObterDadosGeo(int empreendimento, BancoDeDados banco = null)
        {
            SilviculturaATV caracterizacao = new SilviculturaATV();

            caracterizacao.EmpreendimentoId = empreendimento;

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                #region Dados Geo

                Comando comando = bancoDeDados.CriarComando(@"
					select a.atividade,
						   a.codigo    Identificacao,
						   3           GeometriaTipo,
						   a.area_m2   TotalCroqui
					  from {1}geo_aativ a, 
						   {0}crt_projeto_geo g, 
						   {0}lov_caracterizacao_tipo lc
					 where a.atividade = lc.texto
					   and a.projeto = g.id
					   and lc.id = :caracterizacao
					   and g.empreendimento = :empreendimento
					   and g.caracterizacao = :caracterizacao
					union all
					select a.atividade,
						   a.codigo    Identificacao,
						   2           GeometriaTipo,
						   null        TotalCroqui
					  from {1}geo_lativ a, 
						   {0}crt_projeto_geo g, 
						   {0}lov_caracterizacao_tipo lc
					 where a.atividade = lc.texto
					   and a.projeto = g.id
					   and lc.id = :caracterizacao
					   and g.empreendimento = :empreendimento
					   and g.caracterizacao = :caracterizacao
					union all
					select a.atividade,
						   a.codigo    Identificacao,
						   1           GeometriaTipo,
						   null        TotalCroqui
					  from {1}geo_pativ a, 
						   {0}crt_projeto_geo g, 
						   {0}lov_caracterizacao_tipo lc
					 where a.atividade = lc.texto
					   and a.projeto = g.id
					   and lc.id = :caracterizacao
					   and g.empreendimento = :empreendimento
					   and g.caracterizacao = :caracterizacao
					union all
					select a.atividade,
						   a.codigo    Identificacao,
						   3           GeometriaTipo,
						   a.area_m2   TotalCroqui
					  from {1}geo_aiativ a, 
						   {0}crt_projeto_geo g, 
						   {0}lov_caracterizacao_tipo lc
					 where a.atividade = lc.texto
					   and a.projeto = g.id
					   and lc.id = :caracterizacao
					   and g.empreendimento = :empreendimento
					   and g.caracterizacao = :caracterizacao"                    , EsquemaBanco, EsquemaBancoGeo);

                comando.AdicionarParametroEntrada("empreendimento", empreendimento, DbType.Int32);
                comando.AdicionarParametroEntrada("caracterizacao", (int)eCaracterizacao.SilviculturaATV, DbType.Int32);

                caracterizacao.Caracteristicas = bancoDeDados.ObterEntityList <SilviculturaCaracteristicaATV>(comando, (IDataReader reader, SilviculturaCaracteristicaATV item) =>
                {
                    item.TotalCroqui = reader.GetValue <Decimal>("TotalCroqui");
                });

                #endregion

                #region Areas

                int projetoDomId = 0;

                comando = bancoDeDados.CriarComando(@"select g.id from {0}crt_projeto_geo g where g.empreendimento = :empreendimento and g.caracterizacao = :caracterizacao_dom", EsquemaBanco, EsquemaBancoGeo);

                comando.AdicionarParametroEntrada("empreendimento", empreendimento, DbType.Int32);
                comando.AdicionarParametroEntrada("caracterizacao_dom", (int)eCaracterizacao.Dominialidade, DbType.Int32);

                projetoDomId = Convert.ToInt32(bancoDeDados.ExecutarScalar(comando));

                comando = bancoDeDados.CriarComando(@"
					select 0              Id,
						   tab_areas.area Valor,
						   la.id          Tipo,
						   la.texto       TipoTexto,
						   la.descricao   Descricao
					  from (select sum(t.area_m2) area, 1 /*Área total - ATP (m²)*/ tipo
							  from {1}geo_atp t
							 where t.projeto = :projetoDominialidade
							union all
							select sum(t.area_m2) area, 2 /*Área de vegetação nativa (m²)*/ tipo
							  from {1}geo_avn t
							 where t.projeto = :projetoDominialidade
							union all
							select ta.valor area, la.id /*Declividade predominante (graus)*/
							  from {0}lov_crt_silvic_atv_area la, {0}crt_silvicultura_atv_areas ta
							 where la.id = ta.tipo(+)
							   and la.id = 3
							   and :projetoDominialidade = ta.caracterizacao(+)
							union all
							select sum(t.area_m2) area,
								   4 /*Área de floresta plantada (m²)*/ tipo
							  from {1}geo_aa t
							 where t.projeto = :projetoDominialidade
							   and t.vegetacao = 'FLORESTA-PLANTADA'
							union all
							select ta.valor area, la.id /*Área de outro fomento (m²)*/ tipo
							  from {0}lov_crt_silvic_atv_area la, {0}crt_silvicultura_atv_areas ta
							 where la.id = ta.tipo(+)
							   and la.id = 5
							   and :projetoDominialidade = ta.caracterizacao(+)
							union all
							select ta.valor area, la.id /*Área de plantio próprio (m²)*/ tipo
							  from {0}lov_crt_silvic_atv_area la, {0}crt_silvicultura_atv_areas ta
							 where la.id = ta.tipo(+)
							   and la.id = 6
							   and :projetoDominialidade = ta.caracterizacao(+)
							union all
							select (select sum(t.area_m2)
							  from {1}geo_areas_calculadas t
							 where t.projeto = :projetoDominialidade
							   and t.tipo = 'APP_APMP'
							 group by t.tipo) area, 7 /*APP (m²)*/tipo from dual
							union all
							select 0 area, 8 /*Total de floresta (m²)*/ tipo from dual
							union all
							select (select sum(t.area_m2)
									  from {1}geo_arl t
									 where t.projeto = :projetoDominialidade
									   and t.situacao in ('PRESERV')
									 group by t.situacao) area,
								   l.id /*Com vegetação nativa (m²)*/ tipo
							  from {0}lov_crt_silvic_atv_area l
							 where l.id = 9
							union all
							select (select sum(t.area_m2)
									  from {1}geo_arl t
									 where t.projeto = :projetoDominialidade
									   and t.situacao in ('USO')
									 group by t.situacao) area,
								   l.id /*Em uso (m²)*/ tipo
							  from {0}lov_crt_silvic_atv_area l
							 where l.id = 10
							union all
							select (select sum(t.area_m2)
									  from {1}geo_arl t
									 where t.projeto = :projetoDominialidade
									   and t.situacao in ('REC')
									 group by t.situacao) area,
								   l.id /*A recuperar (m²)*/ tipo
							  from {0}lov_crt_silvic_atv_area l
							 where l.id = 11
							union all
							select (select sum(t.area_m2)
									  from {1}geo_arl t
									 where t.projeto = :projetoDominialidade
									   and t.situacao in ('D')
									 group by t.situacao) area,
								   l.id /*Não caracterizada (m²)*/ tipo
							  from {0}lov_crt_silvic_atv_area l
							 where l.id = 12) tab_areas,
						   {0}lov_crt_silvic_atv_area la
					 where tab_areas.tipo = la.id"                    , EsquemaBanco, EsquemaBancoGeo);

                comando.AdicionarParametroEntrada("projetoDominialidade", projetoDomId, DbType.Int32);

                caracterizacao.Areas = bancoDeDados.ObterEntityList <SilviculturaAreaATV>(comando, (IDataReader reader, SilviculturaAreaATV item) =>
                {
                    item.Valor      = reader.GetValue <Decimal>("Valor");
                    item.ValorTexto = reader.GetValue <Decimal>("Valor").ToStringTrunc();
                });
            }

            #endregion

            return(caracterizacao);
        }