private void ValidarEmpreendimentoCedente(ReservaLegal reserva)
{
if (reserva.MatriculaId.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalMatriculaCedenteObrigatorio);
}
if (reserva.IdentificacaoARLCedente <= 0)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalIdentificacaoARLObrigatoria);
}
if (!Validacao.EhValido)
{
return;
}
Dominialidade dominialidadeCedente = _daInterno.ObterPorEmpreendimento(reserva.EmpreendimentoCompensacao.Id);
if (dominialidadeCedente.Id <= 0)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalEmpreendimentoCedenteNaoPossuiDominialidade);
}
if (reserva.MatriculaId.GetValueOrDefault() > 0 && !dominialidadeCedente.Dominios.Exists(x => x.Id == reserva.MatriculaId.GetValueOrDefault()))
{
Validacao.Add(Mensagem.Dominialidade.MatriculaSelecionadaNaoEstaMaisVinculadaCedente);
}
if (!dominialidadeCedente.Dominios.SelectMany(x => x.ReservasLegais).ToList().Exists(x => x.Id == reserva.IdentificacaoARLCedente))
{
Validacao.Add(Mensagem.Dominialidade.RLSelecionadaNaoEstaMaisVinculadaCedente);
}
}
internal Dominialidade Obter(int id, BancoDeDados banco = null, string tid = null, bool simplificado = false)
{
Dominialidade caracterizacao = new Dominialidade();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco, EsquemaBanco))
{
#region Dominialidade
if (tid == null)
{
caracterizacao = Obter(id, bancoDeDados, simplificado);
}
else
{
Comando comando = bancoDeDados.CriarComando(@"select count(s.id) existe from {0}crt_dominialidade 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);
}
#endregion
}
return(caracterizacao);
}
public ActionResult Criar(int id)
{
if (!_caracterizacaoValidar.Basicas(id))
{
return(RedirectToAction("Index", "../Empreendimento", Validacao.QueryParamSerializer()));
}
Dominialidade caracterizacao = _bus.ObterDadosGeo(id);
if (!_caracterizacaoValidar.Dependencias(id, (int)eCaracterizacao.Dominialidade) || !_validar.Dominios(caracterizacao.Dominios))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() }));
}
int zona = _busEmpreendimento.ObterEnderecoZona(id);
caracterizacao.Dominios.ForEach(x => x.EmpreendimentoLocalizacao = zona);
caracterizacao.EmpreendimentoId = id;
caracterizacao.Dependencias = _caracterizacaoBus.ObterDependenciasAtual(id, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
DominialidadeVM vm = new DominialidadeVM(caracterizacao, _listaBus.BooleanLista);
vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
return(View(vm));
}
public Dominialidade ObterHistorico(int dominialidadeID, string dominialidadeTID, bool simplificado = false)
{
Dominialidade caracterizacao = null;
try
{
caracterizacao = _da.Obter(dominialidadeID, tid: dominialidadeTID, simplificado: simplificado);
caracterizacao.Dependencias = _busCaracterizacao.ObterDependencias(caracterizacao.Id, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao, caracterizacao.Tid);
foreach (Dominio dominio in caracterizacao.Dominios)
{
foreach (ReservaLegal reserva in dominio.ReservasLegais)
{
if (!string.IsNullOrEmpty(reserva.MatriculaIdentificacao))
{
Dominio dominioAux = caracterizacao.Dominios.SingleOrDefault(x => x.Identificacao == reserva.MatriculaIdentificacao);
if (dominioAux == null)
{
continue;
}
reserva.MatriculaTexto = dominioAux.Matricula + " - " + dominioAux.Folha + " - " + dominioAux.Livro;
}
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
public void ObterDominialidadeARL(Dominialidade dominialidade)
{
dominialidade.Areas.RemoveAll(x =>
x.Tipo == (int)eDominialidadeArea.ARL_CEDENTE ||
x.Tipo == (int)eDominialidadeArea.ARL_RECEPTOR ||
x.Tipo == (int)eDominialidadeArea.ARL_PRESERVADA ||
x.Tipo == (int)eDominialidadeArea.ARL_RECUPERACAO ||
x.Tipo == (int)eDominialidadeArea.ARL_USO);
//TODO Pegar todas as ARLs.
dominialidade.Areas.Add(new DominialidadeArea()
{
Tipo = (int)eDominialidadeArea.ARL_CEDENTE, Valor = dominialidade.ARLCedente
});
dominialidade.Areas.Add(new DominialidadeArea()
{
Tipo = (int)eDominialidadeArea.ARL_RECEPTOR, Valor = dominialidade.ARLReceptor
});
dominialidade.Areas.Add(new DominialidadeArea()
{
Tipo = (int)eDominialidadeArea.ARL_PRESERVADA, Valor = dominialidade.ARLPreservadaCompensada
});
dominialidade.Areas.Add(new DominialidadeArea()
{
Tipo = (int)eDominialidadeArea.ARL_RECUPERACAO, Valor = dominialidade.ARLRecuperacaoCompensada
});
dominialidade.Areas.Add(new DominialidadeArea()
{
Tipo = (int)eDominialidadeArea.ARL_USO, Valor = dominialidade.ARLUsoCompensada
});
}
public Dominialidade ObterPorEmpreendimento(int empreendimento, bool simplificado = false, BancoDeDados banco = null)
{
Dominialidade caracterizacao = null;
try
{
caracterizacao = _da.ObterPorEmpreendimento(empreendimento, simplificado: simplificado);
foreach (Dominio dominio in caracterizacao.Dominios)
{
foreach (ReservaLegal reserva in dominio.ReservasLegais)
{
if (!string.IsNullOrEmpty(reserva.MatriculaIdentificacao))
{
Dominio dominioAux = caracterizacao.Dominios.SingleOrDefault(x => x.Identificacao == reserva.MatriculaIdentificacao);
if (dominioAux == null)
{
continue;
}
reserva.MatriculaTexto = dominioAux.Matricula + " - " + dominioAux.Folha + " - " + dominioAux.Livro;
}
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
public ActionResult Criar(int id, int projetoDigitalId)
{
if (!_caracterizacaoValidar.Basicas(id))
{
return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
}
Dominialidade caracterizacao = _bus.ObterDadosGeo(id);
if (!_caracterizacaoValidar.Dependencias(empreendimentoId: id, projetoDigitalId: projetoDigitalId, caracterizacaoTipo: (int)eCaracterizacao.Dominialidade) || !_validar.Dominios(caracterizacao.Dominios))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, projetoDigitalId = projetoDigitalId, Msg = Validacao.QueryParam() }));
}
int zona = _busEmpreendimento.Obter(id, simplificado: false).Enderecos
.Where(z => z.Correspondencia == 0)
.Select(z => z.ZonaLocalizacaoId).FirstOrDefault() ?? 0;
caracterizacao.Dominios.ForEach(x => x.EmpreendimentoLocalizacao = zona);
caracterizacao.EmpreendimentoId = id;
caracterizacao.EmpreendimentoInternoId = _busEmpreendimento.ObterEmpreendimento(id, simplificado: true).InternoId.GetValueOrDefault();
caracterizacao.Dependencias = _caracterizacaoBus.ObterDependenciasAtual(id, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
DominialidadeVM vm = new DominialidadeVM(caracterizacao, ListaCredenciadoBus.BooleanLista);
vm.ProjetoDigitalId = projetoDigitalId;
vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
return(View(vm));
}
public ActionResult Editar(int id, int empreendimento, int tipo, bool isCadastrarCaracterizacao = true, bool mostrarModalDependencias = true)
{
if (!_validar.Dependencias(empreendimento, tipo))
{
return(RedirectToAction("", "Caracterizacao", new { id = empreendimento, Msg = Validacao.QueryParam() }));
}
ProjetoGeograficoVM vm = new ProjetoGeograficoVM();
vm.isCadastrarCaracterizacao = isCadastrarCaracterizacao;
vm.IsCredenciado = false;
vm.UrlVoltar = Url.Action("../Caracterizacao/Index", new { id = empreendimento });
vm.Projeto = _bus.ObterProjeto(id);
Dominialidade dominialidade = null;
if (vm.IsFinalizado)
{
dominialidade = new DominialidadeBus().ObterDadosGeo(empreendimento);
}
else
{
dominialidade = new DominialidadeBus().ObterDadosGeoTMP(empreendimento);
}
vm.PossuiAPPNaoCaracterizada = dominialidade.AreaAPPNaoCaracterizada.MaiorToleranciaM2();
vm.PossuiARLNaoCaracterizada = dominialidade.ARLNaoCaracterizada.MaiorToleranciaM2();
//Carregar os dados do projeto geográfico
return(Carregar(vm, mostrarModalDependencias));
}
public bool CopiarDadosInstitucional(int empreendimentoID, int empreendimentoInternoID, BancoDeDados banco)
{
if (banco == null)
{
return(false);
}
if (_validar == null)
{
_validar = new DominialidadeValidar();
}
#region Configurar Caracterização
DominialidadeInternoBus dominialidadeInternoBus = new DominialidadeInternoBus();
Dominialidade caracterizacao = dominialidadeInternoBus.ObterPorEmpreendimento(empreendimentoInternoID);
caracterizacao.EmpreendimentoId = empreendimentoID;
caracterizacao.InternoID = caracterizacao.Id;
caracterizacao.InternoTID = caracterizacao.Tid;
caracterizacao.Areas.ForEach(r => { r.Id = 0; });
caracterizacao.Dominios.ForEach(r => { r.Id = 0; });
caracterizacao.Dominios.SelectMany(x => x.ReservasLegais).ToList().ForEach(r => { r.Id = 0; });
#endregion
if (_validar.CopiarDadosInstitucional(caracterizacao))
{
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco, EsquemaCredenciadoBanco))
{
bancoDeDados.IniciarTransacao();
//Setar ID do credenciado
caracterizacao.Id = ObterPorEmpreendimento(empreendimentoID, simplificado: true, banco: bancoDeDados).Id;
_da.CopiarDadosInstitucional(caracterizacao, bancoDeDados);
#region Dependencias
//Gerencia as dependências da caracterização
caracterizacao.Dependencias = _busCaracterizacao.ObterDependenciasAtual(empreendimentoID, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
_busCaracterizacao.Dependencias(new Caracterizacao()
{
Id = caracterizacao.Id,
Tipo = eCaracterizacao.Dominialidade,
DependenteTipo = eCaracterizacaoDependenciaTipo.Caracterizacao,
Dependencias = caracterizacao.Dependencias
}, bancoDeDados);
#endregion
bancoDeDados.Commit();
}
}
return(Validacao.EhValido);
}
internal bool CopiarDadosInstitucional(Dominialidade caracterizacao)
{
if (caracterizacao.InternoID <= 0)
{
Validacao.Add(Mensagem.Dominialidade.CopiarCaractizacaoCadastrada);
}
return(Validacao.EhValido);
}
internal bool CopiarDadosCredenciado(Dominialidade caracterizacao)
{
if (caracterizacao.CredenciadoID <= 0)
{
Validacao.Add(Mensagem.Dominialidade.CopiarCaractizacaoCadastrada);
}
return(Validacao.EhValido);
}
public Dominialidade ObterPorEmpreendimento(int empreendimento, bool simplificado = false, BancoDeDados banco = null, bool isVisualizar = false)
{
Dominialidade caracterizacao = null;
try
{
caracterizacao = _da.ObterPorEmpreendimento(empreendimento, simplificado: simplificado);
caracterizacao.Dependencias = _busCaracterizacao.ObterDependencias(caracterizacao.Id, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
Dominialidade caracterizacaoGeo = _da.ObterDadosGeo(empreendimento);
caracterizacao.ATPCroqui = caracterizacaoGeo.ATPCroqui;
caracterizacao.Dominios.SelectMany(caract => caract.ReservasLegais).ToList().ForEach(reserva =>
{
caracterizacaoGeo.Dominios.SelectMany(caractGeo => caractGeo.ReservasLegais)
.Where(reservaGeo => reservaGeo.Identificacao == reserva.Identificacao).ToList().ForEach(r =>
{
reserva.Coordenada.EastingUtm = r.Coordenada.EastingUtm;
reserva.Coordenada.NorthingUtm = r.Coordenada.NorthingUtm;
reserva.SituacaoVegetalId = r.SituacaoVegetalId;
reserva.SituacaoVegetalTexto = r.SituacaoVegetalTexto;
});
});
foreach (Dominio dominio in caracterizacao.Dominios)
{
foreach (ReservaLegal reserva in dominio.ReservasLegais)
{
if (!string.IsNullOrEmpty(reserva.MatriculaIdentificacao))
{
Dominio dominioAux = caracterizacao.Dominios.SingleOrDefault(x => x.Identificacao == reserva.MatriculaIdentificacao);
if (dominioAux == null)
{
continue;
}
reserva.MatriculaTexto = dominioAux.Matricula + " - " + dominioAux.Folha + " - " + dominioAux.Livro;
}
}
}
//poderia ser qualquer uma das novas areas da release 2.2.33.0
if (!isVisualizar && !caracterizacao.Areas.Exists(x => x.Tipo == (int)eDominialidadeArea.ARL_PRESERVADA))
{
ObterDominialidadeARL(caracterizacao);
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
public ActionResult AtualizarGrupoARL(Dominialidade caracterizacao)
{
_bus.ObterDominialidadeARL(caracterizacao);
DominialidadeVM vm = new DominialidadeVM(caracterizacao, new List <Lista>());
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@Html = ViewModelHelper.RenderPartialViewToString(ControllerContext, "DominialidadeARLPartial", vm)
}, JsonRequestBehavior.AllowGet));
}
public ActionResult Editar(int id, int projetoDigitalId)
{
if (!_caracterizacaoValidar.Basicas(id))
{
return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
}
if (!_caracterizacaoValidar.Dependencias(id, projetoDigitalId, (int)eCaracterizacao.Dominialidade))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, projetoDigitalId = projetoDigitalId, Msg = Validacao.QueryParam() }));
}
if (!_validar.ProjetoFinalizado(id))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, projetoDigitalId = projetoDigitalId, Msg = Validacao.QueryParam() }));
}
Dominialidade caracterizacao = _bus.ObterPorEmpreendimento(id);
string textoMerge = _caracterizacaoValidar.DependenciasAlteradas(
caracterizacao.EmpreendimentoId,
(int)eCaracterizacao.Dominialidade,
eCaracterizacaoDependenciaTipo.Caracterizacao,
caracterizacao.Dependencias);
if (!string.IsNullOrEmpty(textoMerge))
{
caracterizacao = _bus.MergiarGeo(caracterizacao);
if (!_validar.Dominios(caracterizacao.Dominios))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() }));
}
}
foreach (var dominio in caracterizacao.Dominios)
{
foreach (var reserva in dominio.ReservasLegais)
{
if (!LocalizacoesReserva(reserva, (int)dominio.Tipo).Any(x => x.Id == reserva.LocalizacaoId.ToString()))
{
reserva.LocalizacaoId = 0;
}
}
}
caracterizacao.EmpreendimentoInternoId = _busEmpreendimento.ObterEmpreendimento(id, simplificado: true).InternoId.GetValueOrDefault();
DominialidadeVM vm = new DominialidadeVM(caracterizacao, ListaCredenciadoBus.BooleanLista);
vm.TextoMerge = textoMerge;
vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
vm.ProjetoDigitalId = projetoDigitalId;
return(View(vm));
}
public ActionResult GeoMergiar(Dominialidade caracterizacao)
{
DominialidadeVM vm = new DominialidadeVM(_bus.MergiarGeo(caracterizacao), ListaCredenciadoBus.BooleanLista);
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@Html = ViewModelHelper.RenderPartialViewToString(ControllerContext, "DominialidadePartial", 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 (!_caracterizacaoValidar.Dependencias(id, (int)eCaracterizacao.Dominialidade))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() }));
}
if (!_validar.ProjetoFinalizado(id))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() }));
}
Dominialidade caracterizacao = _bus.ObterPorEmpreendimento(id);
string textoMerge = _caracterizacaoValidar.DependenciasAlteradas(
caracterizacao.EmpreendimentoId,
(int)eCaracterizacao.Dominialidade,
eCaracterizacaoDependenciaTipo.Caracterizacao,
caracterizacao.Dependencias);
if (!string.IsNullOrEmpty(textoMerge))
{
caracterizacao = _bus.MergiarGeo(caracterizacao);
if (!_validar.Dominios(caracterizacao.Dominios))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() }));
}
}
foreach (var dominio in caracterizacao.Dominios)
{
foreach (var reserva in dominio.ReservasLegais)
{
if (!LocalizacoesReserva(reserva, (int)dominio.Tipo).Any(x => x.Id == reserva.LocalizacaoId.ToString()))
{
reserva.LocalizacaoId = 0;
}
}
}
DominialidadeVM vm = new DominialidadeVM(caracterizacao, _listaBus.BooleanLista);
vm.TextoMerge = textoMerge;
vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
return(View(vm));
}
public bool Desatualizado(int id, string caracterizacaoCredenciadoTID)
{
try
{
Dominialidade caracterizacao = _da.Obter(id, simplificado: true);
return(caracterizacaoCredenciadoTID != caracterizacao.Tid);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(false);
}
public ActionResult Visualizar(int id)
{
if (!_caracterizacaoValidar.Dependencias(id, (int)eCaracterizacao.Dominialidade))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() }));
}
Dominialidade caracterizacao = _bus.ObterPorEmpreendimento(id, isVisualizar: true);
DominialidadeVM vm = new DominialidadeVM(caracterizacao, _listaBus.BooleanLista, true);
vm.UrlRetorno = Url.Action("", "Caracterizacao", new { id = caracterizacao.EmpreendimentoId });
return(View(vm));
}
public DominialidadePDF(Dominialidade dominialidade)
{
Id = dominialidade.Id;
ConfrontacaoNorte = dominialidade.ConfrontacaoNorte;
ConfrontacaoLeste = dominialidade.ConfrontacaoLeste;
ConfrontacaoOeste = dominialidade.ConfrontacaoOeste;
ConfrontacaoSul = dominialidade.ConfrontacaoSul;
Areas = dominialidade.Areas;
VegetacaoNativaTotalDecimal = dominialidade.AreaVegetacaoNativa;
TotalFlorestaDecimal = dominialidade.TotalFloresta;
TotalFlorestaPlantadaDecimal = dominialidade.AreaFlorestaPlantada;
Dominios = dominialidade.Dominios.Select(x => new DominioPDF(x)).ToList();
AreaDocumento = dominialidade.AreaDocumento;
}
public DominialidadeVM(Dominialidade caracterizacao, List <Lista> booleanLista, bool isVisualizar = false)
{
Caracterizacao = caracterizacao;
IsVisualizar = isVisualizar;
int selecionado = -1;
if (caracterizacao.PossuiAreaExcedenteMatricula.HasValue)
{
selecionado = caracterizacao.PossuiAreaExcedenteMatricula.GetValueOrDefault();
}
BooleanLista = ViewModelHelper.CriarSelectList(booleanLista, itemTextoPadrao: false, selecionado: selecionado.ToString());
}
public ActionResult VisualizarCredenciado(int projetoDigitalId, int protocoloId = 0)
{
ProjetoDigitalCredenciadoBus _busProjetoDigitalCredenciado = new ProjetoDigitalCredenciadoBus();
ProjetoDigital projeto = _busProjetoDigitalCredenciado.Obter(projetoDigitalId);
Dominialidade caracterizacao = _busCredenciado.ObterPorEmpreendimento(projeto.EmpreendimentoId.GetValueOrDefault(), projetoDigitalId);
DominialidadeVM vm = new DominialidadeVM(caracterizacao, ListaCredenciadoBus.BooleanLista, true);
vm.ProtocoloId = protocoloId;
vm.ProjetoDigitalId = projeto.Id;
vm.RequerimentoId = projeto.RequerimentoId;
vm.UrlRetorno = Url.Action("Analisar", "../AnaliseItens", new { protocoloId = protocoloId, requerimentoId = projeto.RequerimentoId });
return(View("Visualizar", vm));
}
public DominialidadePDF(Dominialidade dominialidade)
{
Id = dominialidade.Id;
ConfrontacaoNorte = dominialidade.ConfrontacaoNorte;
ConfrontacaoLeste = dominialidade.ConfrontacaoLeste;
ConfrontacaoOeste = dominialidade.ConfrontacaoOeste;
ConfrontacaoSul = dominialidade.ConfrontacaoSul;
Areas = dominialidade.Areas;
VegetacaoNativaTotalDecimal = dominialidade.AreaVegetacaoNativa;
TotalFlorestaDecimal = dominialidade.TotalFloresta;
TotalFlorestaPlantadaDecimal = dominialidade.AreaFlorestaPlantada;
Dominios = dominialidade.Dominios.Select(x => new DominioPDF(x)).ToList();
AreaDocumento = dominialidade.AreaDocumento;
ATPCroquiHa = dominialidade.ATPCroqui.Convert(eMetrica.M2ToHa).ToStringTrunc(4);
}
public ActionResult Visualizar(int id, int empreendimento, int projetoDigitalId, int tipo, bool isCadastrarCaracterizacao = true, bool mostrarModalDependencias = true, bool retornarVisualizar = true)
{
ProjetoGeograficoVM vm = new ProjetoGeograficoVM();
vm.isCadastrarCaracterizacao = isCadastrarCaracterizacao;
ProjetoDigitalCredenciadoBus projetoDigitalBus = new ProjetoDigitalCredenciadoBus();
List <Dependencia> dependenciasPD = projetoDigitalBus.ObterDependencias(projetoDigitalId);
Dependencia dependencia = dependenciasPD.SingleOrDefault(x => x.DependenciaCaracterizacao == tipo && x.DependenciaTipo == (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico) ?? new Dependencia();
vm.Projeto = _bus.ObterHistorico(dependencia.DependenciaId, dependencia.DependenciaTid);
vm.IsVisualizar = true;
vm.Desenhador.IsVisualizar = true;
vm.Sobreposicoes.MostrarVerificar = false;
vm.BaseReferencia.IsVisualizar = true;
vm.Importador.IsVisualizar = true;
vm.IsProcessado = _bus.IsProcessado(vm.Projeto.Id, (eCaracterizacao)tipo);
Boolean podeCriarEditar = new PermissaoValidar().ValidarAny(new[] { ePermissao.ProjetoGeograficoCriar, ePermissao.ProjetoGeograficoEditar }, false);
if (!String.IsNullOrWhiteSpace(vm.TextoMerge) && !podeCriarEditar)
{
Validacao.Add(Mensagem.ProjetoGeografico.NaoPodeVisualizarComDependenciasAlteradas(vm.Projeto.CaracterizacaoTexto));
return(RedirectToAction("", "Caracterizacao", new { id = empreendimento, projetoDigitalId = projetoDigitalId, Msg = Validacao.QueryParam() }));
}
Dominialidade dominialidade = null;
if (vm.IsFinalizado)
{
dominialidade = new DominialidadeBus().ObterDadosGeo(empreendimento);
}
else
{
dominialidade = new DominialidadeBus().ObterDadosGeoTMP(empreendimento);
}
vm.PossuiAPPNaoCaracterizada = dominialidade.AreaAPPNaoCaracterizada.MaiorToleranciaM2();
vm.PossuiARLNaoCaracterizada = dominialidade.ARLNaoCaracterizada.MaiorToleranciaM2();
vm.MostrarAvancar = !dependenciasPD.Exists(x => x.DependenciaCaracterizacao == tipo);
vm.RetornarVisualizar = retornarVisualizar;
//Carregar os dados do projeto geográfico
return(Carregar(vm, projetoDigitalId, mostrarModalDependencias, isVisualizar: true));
}
public Dominialidade ObterDadosGeo(int empreendimento, BancoDeDados banco = null)
{
Dominialidade dominialidade = new Dominialidade();
try
{
dominialidade = _da.ObterDadosGeo(empreendimento);
ObterDominialidadeARL(dominialidade);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(dominialidade);
}
public ActionResult Visualizar(int id, int empreendimento, int tipo, bool isCadastrarCaracterizacao = true, bool mostrarModalDependencias = true)
{
if (tipo == (int)eCaracterizacao.RegularizacaoFundiaria && !permissaoValidar.ValidarAny(new[] { ePermissao.RegularizacaoFundiariaVisualizar }))
{
return(RedirectToAction("", "Caracterizacao", new { id = empreendimento, Msg = Validacao.QueryParam() }));
}
ProjetoGeograficoVM vm = new ProjetoGeograficoVM();
vm.isCadastrarCaracterizacao = isCadastrarCaracterizacao;
vm.Projeto = _bus.ObterProjeto(id);
vm.IsVisualizar = true;
vm.Desenhador.IsVisualizar = true;
vm.Sobreposicoes.MostarVerificar = false;
vm.BaseReferencia.IsVisualizar = true;
vm.EnviarProjeto.IsVisualizar = true;
vm.IsCredenciado = false;
vm.UrlVoltar = Url.Action("../Caracterizacao/Index", new { id = empreendimento });
Boolean podeCriarEditar = new PermissaoValidar().ValidarAny(new[] { ePermissao.ProjetoGeograficoCriar, ePermissao.ProjetoGeograficoEditar }, false);
if (!String.IsNullOrWhiteSpace(vm.TextoMerge) && !podeCriarEditar)
{
Validacao.Add(Mensagem.ProjetoGeografico.NaoPodeVisualizarComDependenciasAlteradas(vm.Projeto.CaracterizacaoTexto));
return(RedirectToAction("", "Caracterizacao", new { id = vm.Projeto.EmpreendimentoId, Msg = Validacao.QueryParam() }));
}
Dominialidade dominialidade = null;
if (vm.IsFinalizado)
{
dominialidade = new DominialidadeBus().ObterDadosGeo(empreendimento);
}
else
{
dominialidade = new DominialidadeBus().ObterDadosGeoTMP(empreendimento);
}
vm.PossuiAPPNaoCaracterizada = dominialidade.AreaAPPNaoCaracterizada.MaiorToleranciaM2();
vm.PossuiARLNaoCaracterizada = dominialidade.ARLNaoCaracterizada.MaiorToleranciaM2();
//Carregar os dados do projeto geográfico
return(Carregar(vm, mostrarModalDependencias, isVisualizar: true));
}
public string AbrirModalAcessar(int empreendimentoId)
{
EmpreendimentoCaracterizacao empreendimento = _caracterizacaoBus.ObterEmpreendimentoSimplificado(empreendimentoId);
if (empreendimento.ZonaLocalizacao == eZonaLocalizacao.Rural)
{
DominialidadeDa dominialidadeDa = new DominialidadeDa();
Dominialidade dominialidade = dominialidadeDa.ObterPorEmpreendimento(empreendimentoId);
foreach (Dominio dominio in dominialidade.Dominios)
{
if (dominio.ReservasLegais.Exists(x => x.SituacaoId == (int)eReservaLegalSituacao.NaoInformada))
{
return(Mensagem.ExploracaoFlorestal.EmpreendimentoRuralReservaIndefinida.Texto);
}
}
}
return(string.Empty);
}
public RegularizacaoFundiaria ObterDadosGeo(int empreendimento, BancoDeDados banco = null)
{
RegularizacaoFundiaria caracterizacao = new RegularizacaoFundiaria();
try
{
Dominialidade dominialidade = _busDominialidade.ObterPorEmpreendimento(empreendimento);
int zona = (int)_busCaracterizacao.ObterEmpreendimentoSimplificado(empreendimento).ZonaLocalizacao;
caracterizacao.Posses = ObterPosses(empreendimento, zona);
caracterizacao.Matriculas = dominialidade.Dominios.Where(x => x.Tipo == eDominioTipo.Matricula).ToList();
return(caracterizacao);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public ActionResult Criar(Dominialidade caracterizacao)
{
string textoMerge = _caracterizacaoValidar.DependenciasAlteradas(
caracterizacao.EmpreendimentoId,
(int)eCaracterizacao.Dominialidade,
eCaracterizacaoDependenciaTipo.Caracterizacao,
caracterizacao.Dependencias);
if (!string.IsNullOrEmpty(textoMerge))
{
return(Json(new { @TextoMerge = textoMerge }, JsonRequestBehavior.AllowGet));
}
_bus.Salvar(caracterizacao, caracterizacao.ProjetoDigitalId, null);
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@UrlRedirecionar = Url.Action("", "Caracterizacao", new { id = caracterizacao.EmpreendimentoId, projetoDigitalId = caracterizacao.ProjetoDigitalId, Msg = Validacao.QueryParam() })
}, JsonRequestBehavior.AllowGet));
}
public ActionResult Visualizar(int id, int projetoDigitalId, bool retornarVisualizar = true)
{
if (!_caracterizacaoValidar.Basicas(id))
{
return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
}
if (!_caracterizacaoValidar.Dependencias(id, projetoDigitalId, (int)eCaracterizacao.Dominialidade))
{
return(RedirectToAction("", "Caracterizacao", new { id = id, projetoDigitalId = projetoDigitalId, Msg = Validacao.QueryParam() }));
}
Dominialidade caracterizacao = _bus.ObterPorEmpreendimento(id, projetoDigitalId);
caracterizacao.EmpreendimentoInternoId = _busEmpreendimento.ObterEmpreendimento(id, simplificado: true).InternoId.GetValueOrDefault();
DominialidadeVM vm = new DominialidadeVM(caracterizacao, ListaCredenciadoBus.BooleanLista, true);
vm.ProjetoDigitalId = projetoDigitalId;
vm.RetornarVisualizar = retornarVisualizar;
return(View(vm));
}
internal Dominialidade ObterPorEmpreendimento(int empreendimento, bool simplificado = false, BancoDeDados banco = null)
{
Dominialidade caracterizacao = new Dominialidade();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
#region Dominialidade
Comando comando = bancoDeDados.CriarComando(@"select s.id from {0}crt_dominialidade 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);
}
#endregion
}
return(caracterizacao);
}
