public List <int> ObterAtividades(int empreendimentoId, eCaracterizacao caracterizacaoTipo)
{
List <CaracterizacaoLst> caracterizacoes = CaracterizacaoConfig.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes);
string tabela = caracterizacoes.Find(x => x.Id == (int)caracterizacaoTipo).Tabela;
return(_da.ObterAtividadesCaracterizacao(tabela, empreendimentoId));
}
public List <Caracterizacao> Dependentes(int empreendimentoId, eCaracterizacao caracterizacaoTipo, eCaracterizacaoDependenciaTipo tipo, BancoDeDados banco = null)
{
List <Caracterizacao> lista = new List <Caracterizacao>();
List <DependenciaLst> dependentes = _caracterizacaoConfig.Obter <List <DependenciaLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoesDependencias);
dependentes = dependentes.Where(x => x.DependenciaTipo == (int)caracterizacaoTipo && x.TipoId == (int)tipo).ToList();
List <Caracterizacao> caracterizacoes = _da.ObterCaracterizacoes(empreendimentoId, banco);
caracterizacoes = caracterizacoes.Where(x => x.Id > 0 || x.ProjetoId > 0 || x.ProjetoRascunhoId > 0 || x.DscLicAtividadeId > 0).ToList();
Caracterizacao caracterizacao = null;
foreach (DependenciaLst dependente in dependentes)
{
caracterizacao = caracterizacoes.SingleOrDefault(y => (int)y.Tipo == dependente.DependenteTipo) ?? new Caracterizacao();
if (caracterizacao.Id > 0 || (caracterizacao.ProjetoId > 0 || caracterizacao.ProjetoRascunhoId > 0 || caracterizacao.DscLicAtividadeId > 0))
{
lista.Add(caracterizacao);
}
}
return(lista.Distinct().ToList());
}
public void Excluir(int empreendimento, eCaracterizacao tipo, BancoDeDados banco = null)
{
try
{
_da.Excluir(empreendimento, (int)tipo);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
}
public List <ArquivoProjeto> ObterArquivos(int empreendimento, eCaracterizacao caracterizacao, bool finalizado = false)
{
try
{
return(_da.ObterArquivos(empreendimento, caracterizacao, finalizado: finalizado));
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
internal bool DependenciasExcluir(int empreendimentoId, eCaracterizacao caracterizacaoTipo, eCaracterizacaoDependenciaTipo?dependenciaTipo = null)
{
List <Dependencia> dependentes = _da.ObterDependentes(empreendimentoId, caracterizacaoTipo, dependenciaTipo);
List <CaracterizacaoLst> caracterizacoes = _caracterizacaoConfig.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes);
foreach (Dependencia item in dependentes)
{
Validacao.Add(Mensagem.Caracterizacao.DependenciasExcluir(caracterizacoes.SingleOrDefault(x => x.Id == item.DependenciaCaracterizacao).Texto, item.DependenciaTipo == (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico));
}
return(Validacao.EhValido);
}
public List <Dependencia> ObterDependenciasAtual(int empreendimentoId, eCaracterizacao caracterizacaoTipo, eCaracterizacaoDependenciaTipo tipo, BancoDeDados banco = null)
{
try
{
return(_da.ObterDependenciasAtual(empreendimentoId, caracterizacaoTipo, tipo, banco));
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public List <Dependencia> ObterDependencias(int dependenteId, eCaracterizacao caracterizacaoTipo, eCaracterizacaoDependenciaTipo tipo, string tid = "", BancoDeDados banco = null)
{
try
{
return(string.IsNullOrEmpty(tid) ? _da.ObterDependencias(dependenteId, caracterizacaoTipo, tipo, banco) : _da.ObterDependenciasHistorico(dependenteId, caracterizacaoTipo, tipo, tid, banco));
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public bool IsProcessado(int projetoID, eCaracterizacao caracterizacao)
{
try
{
return(_da.VerificarProjetoGeograficoProcessado(projetoID, caracterizacao));
}
catch (Exception e)
{
Validacao.AddErro(e);
}
return(false);
}
public void AtualizarInternoIdTid(int empreendimentoId, int projetoId, eCaracterizacao caracterizacaoTipo, int internoId, string tid, BancoDeDados banco = null)
{
_da.AtualizarInternoIdTid(projetoId, internoId, tid, banco);
List <Dependencia> dependencias = _caracterizacaoBus.ObterDependenciasAtual(empreendimentoId, caracterizacaoTipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico, banco);
_caracterizacaoBus.Dependencias(new Caracterizacao()
{
Id = projetoId,
Tipo = caracterizacaoTipo,
DependenteTipo = eCaracterizacaoDependenciaTipo.ProjetoGeografico,
Dependencias = dependencias
}, banco);
}
public bool Existe(eCaracterizacao caracterizacaoTipo, int empreendimentoId, int projetoDigitalId)
{
List <Caracterizacao> caracterizacoes = _da.ObterCaracterizacoes(empreendimentoId, projetoDigitalId);
Caracterizacao caracterizacao = caracterizacoes.SingleOrDefault(x => x.Tipo == caracterizacaoTipo);
if (caracterizacao.Id <= 0)
{
Validacao.Add(Mensagem.Caracterizacao.CaracterizacaoInexistente(caracterizacao.Nome));
return(false);
}
return(true);
}
private static CaracterizacaoPDF ObterDadosCulturas(IEspecificidade especificidade)
{
eCaracterizacao eTipoCaracterizacao = eCaracterizacao.Silvicultura;
int atividadeId = AtividadeIdSilvicultura;
if (especificidade.Atividades.Exists(x => x.Id == AtividadeIdPulverizacao))
{
eTipoCaracterizacao = eCaracterizacao.PulverizacaoProduto;
atividadeId = AtividadeIdPulverizacao;
}
ICaracterizacaoBus caractBus = CaracterizacaoBusFactory.Criar(eTipoCaracterizacao);
return(caractBus.ObterDadosPdfTitulo(especificidade.Titulo.EmpreendimentoId.Value, atividadeId, especificidade) as CaracterizacaoPDF);
}
public List <Lista> ObterCoordenadaAtividadeLst(int empreendimentoId, eCaracterizacao caracterizacaoTipo, eTipoGeometria tipoGeo)
{
List <Lista> coordenadas = new List <Lista>();
foreach (CoordenadaAtividade item in _da.ObterCoordenadas(empreendimentoId, caracterizacaoTipo, tipoGeo))
{
Lista itemLista = new Lista();
itemLista.Id = item.Id.ToString() + "|" + item.CoordX + "|" + item.CoordY;
itemLista.Texto = item.CoordenadasAtividade;
itemLista.IsAtivo = true;
coordenadas.Add(itemLista);
}
return(coordenadas);
}
public DescricaoLicenciamentoAtividade ObterDadosGeo(int id, eCaracterizacao tipo, DescricaoLicenciamentoAtividade dscLicAtv = null)
{
dscLicAtv = dscLicAtv ?? new DescricaoLicenciamentoAtividade();
try
{
DescricaoLicenciamentoAtividade dscLicAtvTemp = _da.ObterDadosGeo(id, tipo);
dscLicAtv.AreaTerreno = dscLicAtvTemp.AreaTerreno;
dscLicAtv.ExisteAppUtil = dscLicAtvTemp.ExisteAppUtil;
dscLicAtv.TipoVegetacaoUtilCodigo = dscLicAtvTemp.TipoVegetacaoUtilCodigo;
dscLicAtv.LocalizadaUCNomeOrgaoAdm = dscLicAtvTemp.LocalizadaUCNomeOrgaoAdm;
dscLicAtv.BaciaHidrografica = dscLicAtvTemp.BaciaHidrografica;
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(dscLicAtv);
}
internal void AtualizarDependentes(int dependenciaID, eCaracterizacao caracterizacaoTipo, eCaracterizacaoDependenciaTipo eCaracterizacaoDependenciaTipo, string dependenciaTID, BancoDeDados banco = null)
{
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
bancoDeDados.IniciarTransacao();
Comando comando = bancoDeDados.CriarComando(@"update crt_dependencia c set c.dependencia_tid = :dependencia_tid, c.tid = :tid
where c.dependencia_id = :dependencia_id and c.dependencia_tipo = :dependencia_tipo and c.dependencia_caracterizacao = :dependencia_caracterizacao" , EsquemaBanco);
comando.AdicionarParametroEntrada("dependencia_caracterizacao", (int)caracterizacaoTipo, DbType.Int32);
comando.AdicionarParametroEntrada("dependencia_tipo", (int)eCaracterizacaoDependenciaTipo, DbType.Int32);
comando.AdicionarParametroEntrada("dependencia_id", dependenciaID, DbType.Int32);
comando.AdicionarParametroEntrada("dependencia_tid", DbType.String, 36, dependenciaTID);
comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
bancoDeDados.ExecutarNonQuery(comando);
}
}
public void Excluir(int empreendimento, eCaracterizacao tipo)
{
try
{
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
GerenciadorTransacao.ObterIDAtual();
bancoDeDados.IniciarTransacao();
_da.Excluir(empreendimento, (int)tipo, bancoDeDados);
bancoDeDados.Commit();
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
}
public List <Dependencia> ObterDependencias(int dependenteId, eCaracterizacao caracterizacaoTipo, eCaracterizacaoDependenciaTipo tipo, BancoDeDados banco = null)
{
List <Dependencia> lista = new List <Dependencia>();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
#region Lista das caracterizações do empreendimento
Comando comando = bancoDeDados.CriarComando(@"select d.dependencia_tipo, d.dependencia_caracterizacao, d.dependencia_id, d.dependencia_tid
from {0}crt_dependencia d where d.dependente_tipo = :dependente_tipo and d.dependente_caracterizacao = :dependente_caracterizacao and d.dependente_id = :dependente_id" , EsquemaBanco);
comando.AdicionarParametroEntrada("dependente_tipo", (int)tipo, DbType.Int32);
comando.AdicionarParametroEntrada("dependente_caracterizacao", (int)caracterizacaoTipo, DbType.Int32);
comando.AdicionarParametroEntrada("dependente_id", dependenteId, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
Dependencia dependencia = null;
while (reader.Read())
{
dependencia = new Dependencia();
dependencia.DependenciaTipo = Convert.ToInt32(reader["dependencia_tipo"]);
dependencia.DependenciaCaracterizacao = Convert.ToInt32(reader["dependencia_caracterizacao"]);
dependencia.DependenciaId = Convert.ToInt32(reader["dependencia_id"]);
dependencia.DependenciaTid = reader["dependencia_tid"].ToString();
lista.Add(dependencia);
}
reader.Close();
}
#endregion
}
return(lista);
}
public static ICaracterizacaoBus Criar(eCaracterizacao caracterizacao)
{
switch (caracterizacao)
{
case eCaracterizacao.Nulo:
return(null);
case eCaracterizacao.Dominialidade:
return(new DominialidadeBus());
case eCaracterizacao.UnidadeProducao:
return(new UnidadeProducaoBus());
case eCaracterizacao.UnidadeConsolidacao:
return(new UnidadeConsolidacaoBus());
case eCaracterizacao.BarragemDispensaLicenca:
return(new BarragemDispensaLicencaBus());
default:
return(null);
}
}
public ActionResult Carregar(ProjetoGeograficoVM vm, bool mostrarModalDependencias = true, bool isVisualizar = false)
{
Empreendimento emp = _busEmpreendimento.Obter(vm.Projeto.EmpreendimentoId);
if (emp.Coordenada.EastingUtm.GetValueOrDefault() <= 0 || emp.Coordenada.NorthingUtm.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.ProjetoGeografico.CoordenadaObrigatoria);
return(RedirectToAction("", "Caracterizacao", new { id = vm.Projeto.EmpreendimentoId, Msg = Validacao.QueryParam() }));
}
if (!isVisualizar && !_caracterizacaoValidar.Dependencias(vm.Projeto.EmpreendimentoId, vm.Projeto.CaracterizacaoId, validarProjetoGeoProprio: false))
{
return(RedirectToAction("", "Caracterizacao", new { id = vm.Projeto.EmpreendimentoId, Msg = Validacao.QueryParam() }));
}
eCaracterizacao tipo = (eCaracterizacao)vm.Projeto.CaracterizacaoId;
vm.CaracterizacaoTipo = vm.Projeto.CaracterizacaoId;
vm.ArquivoEnviadoTipo = (int)eProjetoGeograficoArquivoTipo.ArquivoEnviado;
vm.ArquivoEnviadoFilaTipo = (tipo == eCaracterizacao.Dominialidade) ? (int)eFilaTipoGeo.Dominialidade : (int)eFilaTipoGeo.Atividade;
vm.NiveisPrecisao = ViewModelHelper.CriarSelectList(_bus.ObterNiveisPrecisao());
vm.SistemaCoordenada = ViewModelHelper.CriarSelectList(_bus.ObterSistemaCoordenada());
vm.Projeto.EmpreendimentoEasting = emp.Coordenada.EastingUtm.Value;
vm.Projeto.EmpreendimentoNorthing = emp.Coordenada.NorthingUtm.Value;
vm.Projeto.CaracterizacaoTexto = (_listaBus.Caracterizacoes.SingleOrDefault(x => x.Id == vm.Projeto.CaracterizacaoId) ?? new CaracterizacaoLst()).Texto;
vm.Projeto.SistemaCoordenada = ConcatenarSistemaCoordenada(emp);
vm.Dependentes = _caracterizacaoBus.Dependentes(vm.Projeto.EmpreendimentoId, tipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico);
vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
vm.UrlBaixarOrtofoto = _config.Obter <string>(ConfiguracaoSistema.KeyUrlGeoBasesWebServices) + "/Arquivo/DownloadArquivoOrtoFoto";
vm.UrlValidarOrtofoto = _config.Obter <string>(ConfiguracaoSistema.KeyUrlGeoBasesWebServices) + "/Arquivo/ValidarChaveArquivoOrtoFoto";
vm.UrlsArquivo = ViewModelHelper.Json(ObterUrlsArquivo());
#region Verificar o Redirecionamento
vm.UrlAvancar = CaracterizacaoVM.GerarUrl(vm.Projeto.EmpreendimentoId, vm.isCadastrarCaracterizacao, (eCaracterizacao)tipo);
List <DependenciaLst> dependencias = _caracterizacaoConfig.Obter <List <DependenciaLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoesDependencias);
if (dependencias.Exists(x => x.DependenteTipo == (int)tipo && x.TipoDetentorId == (int)eCaracterizacaoDependenciaTipo.DescricaoLicenciamentoAtividade))
{
String url = "Visualizar";
PermissaoValidar permissaoValidar = new PermissaoValidar();
if (permissaoValidar.ValidarAny(new[] { ePermissao.DescricaoLicenciamentoAtividadeCriar, ePermissao.DescricaoLicenciamentoAtividadeEditar }, false))
{
url = "Criar";
}
vm.UrlAvancar = Url.Action(url, "DescricaoLicenciamentoAtividade", new { empreendimento = vm.Projeto.EmpreendimentoId, tipo = (int)tipo, isCadastrarCaracterizacao = vm.isCadastrarCaracterizacao });
}
#endregion
if (vm.Projeto.Dependencias == null || vm.Projeto.Dependencias.Count == 0)
{
vm.Projeto.Dependencias = _caracterizacaoBus.ObterDependenciasAtual(vm.Projeto.EmpreendimentoId, tipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico);
}
if (vm.Projeto.Id > 0 && mostrarModalDependencias)
{
vm.TextoMerge = _caracterizacaoValidar.DependenciasAlteradas(
vm.Projeto.EmpreendimentoId,
vm.Projeto.CaracterizacaoId,
eCaracterizacaoDependenciaTipo.ProjetoGeografico,
vm.Projeto.Dependencias, isVisualizar);
}
vm.Projeto.Dependencias = _caracterizacaoBus.ObterDependenciasAtual(vm.Projeto.EmpreendimentoId, tipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico);
//Busca as dependencias desse projeto geográfico
_bus.ObterDependencias(vm.Projeto, true);
if (vm.Projeto.Id > 0)
{
vm.CarregarVMs();
}
return(View("ProjetoGeografico", vm));
}
public ActionResult VisualizarProjetoGeoCredenciado(int projetoDigitalId, int dependenciaTipo, int protocoloId, int requerimentoId)
{
ProjetoGeograficoVM vm = new ProjetoGeograficoVM()
{
ProtocoloId = protocoloId, RequerimentoId = requerimentoId, IsCredenciado = true
};
Cred.ModuloProjetoGeografico.Bussiness.ProjetoGeograficoBus projetoGeoCredBus = new Cred.ModuloProjetoGeografico.Bussiness.ProjetoGeograficoBus();
Cred.ModuloDominialidade.Business.DominialidadeBus dominialidadeCredBus = new Cred.ModuloDominialidade.Business.DominialidadeBus();
Cred.ModuloCaracterizacao.Bussiness.CaracterizacaoBus caracterizacaoCredBus = new Cred.ModuloCaracterizacao.Bussiness.CaracterizacaoBus();
ProjetoDigitalCredenciadoBus busProjetoDigitalCredenciado = new ProjetoDigitalCredenciadoBus();
List <Dependencia> lstDependencias = busProjetoDigitalCredenciado.ObterDependencias(projetoDigitalId);
Dependencia dependencia = lstDependencias.SingleOrDefault(x => x.DependenciaCaracterizacao == dependenciaTipo && x.DependenciaTipo == (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico) ?? new Dependencia();
vm.Projeto = projetoGeoCredBus.ObterHistorico(dependencia.DependenciaId, dependencia.DependenciaTid);
vm.IsVisualizar = true;
vm.IsVisualizarCredenciado = true;
vm.Desenhador.Mostrar = false;
vm.Sobreposicoes.MostarVerificar = false;
vm.BaseReferencia.IsVisualizar = true;
vm.EnviarProjeto.IsVisualizar = true;
vm.IsProcessado = projetoGeoCredBus.IsProcessado(vm.Projeto.Id, (eCaracterizacao)dependenciaTipo);
Dominialidade dominialidade = dominialidadeCredBus.ObterDadosGeo(vm.Projeto.EmpreendimentoId);
vm.PossuiAPPNaoCaracterizada = dominialidade.AreaAPPNaoCaracterizada.MaiorToleranciaM2();
vm.PossuiARLNaoCaracterizada = dominialidade.ARLNaoCaracterizada.MaiorToleranciaM2();
//Carregar os dados do projeto geográfico
eCaracterizacao tipo = (eCaracterizacao)vm.Projeto.CaracterizacaoId;
vm.ArquivoEnviadoTipo = (int)eProjetoGeograficoArquivoTipo.ArquivoEnviado;
vm.ArquivoEnviadoFilaTipo = (tipo == eCaracterizacao.Dominialidade) ? (int)eFilaTipoGeo.Dominialidade : (int)eFilaTipoGeo.Atividade;
vm.NiveisPrecisao = ViewModelHelper.CriarSelectList(_bus.ObterNiveisPrecisao());
vm.SistemaCoordenada = ViewModelHelper.CriarSelectList(_bus.ObterSistemaCoordenada());
Empreendimento emp = new EmpreendimentoCredenciadoBus().Obter(vm.Projeto.EmpreendimentoId);
vm.Projeto.EmpreendimentoEasting = emp.Coordenada.EastingUtm.Value;
vm.Projeto.EmpreendimentoNorthing = emp.Coordenada.NorthingUtm.Value;
vm.Projeto.CaracterizacaoTexto = (_listaBus.Caracterizacoes.SingleOrDefault(x => x.Id == vm.Projeto.CaracterizacaoId) ?? new CaracterizacaoLst()).Texto;
vm.Projeto.SistemaCoordenada = ConcatenarSistemaCoordenada(emp);
vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
vm.UrlBaixarOrtofoto = _config.Obter <string>(ConfiguracaoSistema.KeyUrlGeoBasesWebServices) + "/Arquivo/DownloadArquivoOrtoFoto";
vm.UrlValidarOrtofoto = _config.Obter <string>(ConfiguracaoSistema.KeyUrlGeoBasesWebServices) + "/Arquivo/ValidarChaveArquivoOrtoFoto";
vm.UrlsArquivo = ViewModelHelper.Json(ObterUrlsArquivo());
vm.UrlVoltar = Url.Action("Analisar", "AnaliseItens", new { protocoloId = protocoloId, requerimentoId = requerimentoId });
#region Verificar o Redirecionamento
vm.UrlAvancar = Url.Action("VisualizarCredenciado", "Dominialidade", new { projetoDigitalId = projetoDigitalId, protocoloId = protocoloId });
List <DependenciaLst> dependencias = _caracterizacaoConfig.Obter <List <DependenciaLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoesDependencias);
#endregion
if (vm.Projeto.Dependencias == null || vm.Projeto.Dependencias.Count == 0)
{
vm.Projeto.Dependencias = _caracterizacaoBus.ObterDependenciasAtual(vm.Projeto.EmpreendimentoId, tipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico);
}
if (vm.Projeto.Id > 0)
{
vm.TextoMerge = _caracterizacaoValidar.DependenciasAlteradas(
vm.Projeto.EmpreendimentoId,
vm.Projeto.CaracterizacaoId,
eCaracterizacaoDependenciaTipo.ProjetoGeografico,
vm.Projeto.Dependencias, true);
}
vm.Projeto.Dependencias = caracterizacaoCredBus.ObterDependenciasAtual(vm.Projeto.EmpreendimentoId, tipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico);
//Busca as dependencias desse projeto geográfico
projetoGeoCredBus.ObterDependencias(vm.Projeto, true);
if (vm.Projeto.Id > 0)
{
vm.CarregarVMs();
}
return(View("ProjetoGeografico", vm));
}
public int Existe(int empreendimento, int projetoDigitalId, eCaracterizacao caracterizacaoTipo)
{
List <Caracterizacao> caracterizacoes = ObterCaracterizacoesEmpreendimento(empreendimento, projetoDigitalId);
return((caracterizacoes.SingleOrDefault(x => x.Tipo == caracterizacaoTipo) ?? new Caracterizacao()).Id);
}
public int Existe(int empreendimento, eCaracterizacao caracterizacaoTipo)
{
List <Caracterizacao> caracterizacoes = ObterCaracterizacoesEmpreendimento(empreendimento);
return((caracterizacoes.OrderByDescending(x => x.Id).FirstOrDefault(x => x.Tipo == caracterizacaoTipo) ?? new Caracterizacao()).Id);
}
public List <Dependencia> ObterDependenciasAlteradas(int empreendimentoId, int dependenteId, eCaracterizacao caracterizacaoTipo, eCaracterizacaoDependenciaTipo tipo)
{
try
{
List <Dependencia> dependenciasBanco = _da.ObterDependenciasAtual(empreendimentoId, caracterizacaoTipo, tipo);
Dependencia dependenciaBanco = null;
List <Dependencia> dependencias = ObterDependencias(dependenteId, caracterizacaoTipo, tipo);
List <Dependencia> dependenciasAteradas = new List <Dependencia>();
foreach (Dependencia item in dependencias)
{
dependenciaBanco = dependenciasBanco.SingleOrDefault(x => x.DependenciaId == item.DependenciaId && x.DependenciaCaracterizacao == item.DependenciaCaracterizacao &&
x.DependenciaTipo == item.DependenciaTipo
) ?? new Dependencia();
if (item.DependenciaTid != dependenciaBanco.DependenciaTid)
{
dependenciasAteradas.Add(dependenciaBanco);
}
}
return(dependenciasAteradas);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(null);
}
public DescricaoLicenciamentoAtividade ObterPorEmpreendimento(int empreendimentoId, eCaracterizacao tipo, bool simplificado = false)
{
DescricaoLicenciamentoAtividade dscLicAtv = new DescricaoLicenciamentoAtividade();
try
{
dscLicAtv = _da.ObterPorEmpreendimento(empreendimentoId: empreendimentoId, tipo: tipo, simplificado: simplificado);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(dscLicAtv);
}
public static string GerarUrl(int projetoDigitalId, int empreendimentoId, bool isCadastrarCaracterizacao, eCaracterizacao tipo)
{
String url = "Visualizar";
PermissaoValidar permissaoValidar = new PermissaoValidar();
ePermissao ePermCriar = (ePermissao)Enum.Parse(typeof(ePermissao), String.Format("{0}Criar", tipo.ToString()));
ePermissao ePermEditar = (ePermissao)Enum.Parse(typeof(ePermissao), String.Format("{0}Editar", tipo.ToString()));
if (isCadastrarCaracterizacao && permissaoValidar.ValidarAny(new[] { ePermCriar }, false))
{
url = "Criar";
}
if (!isCadastrarCaracterizacao && permissaoValidar.ValidarAny(new[] { ePermEditar }, false))
{
url = "Editar";
}
UrlHelper urlHelper = new UrlHelper(HttpContext.Current.Request.RequestContext);
return(urlHelper.Action(url, tipo.ToString(), new { projetoDigitalId = projetoDigitalId, id = empreendimentoId, Msg = Validacao.QueryParam() }));
}
public static ICaracterizacaoBus Criar(eCaracterizacao caracterizacao)
{
switch (caracterizacao)
{
case eCaracterizacao.Nulo:
return(null);
case eCaracterizacao.Dominialidade:
return(new DominialidadeBus());
case eCaracterizacao.RegularizacaoFundiaria:
return(new RegularizacaoFundiariaBus());
case eCaracterizacao.ExploracaoFlorestal:
return(new ExploracaoFlorestalBus());
case eCaracterizacao.QueimaControlada:
return(new QueimaControladaBus());
case eCaracterizacao.SecagemMecanicaGraos:
return(new SecagemMecanicaGraosBus());
case eCaracterizacao.ProducaoCarvaoVegetal:
return(new ProducaoCarvaoVegetalBus());
case eCaracterizacao.DespolpamentoCafe:
return(new DespolpamentoCafeBus());
case eCaracterizacao.Avicultura:
return(new AviculturaBus());
case eCaracterizacao.Suinocultura:
return(new SuinoculturaBus());
case eCaracterizacao.BeneficiamentoMadeira:
return(new BeneficiamentoMadeiraBus());
case eCaracterizacao.Terraplanagem:
return(new TerraplanagemBus());
case eCaracterizacao.SilviculturaPPFF:
return(new SilviculturaPPFFBus());
case eCaracterizacao.Barragem:
return(new BarragemBus());
case eCaracterizacao.RegistroAtividadeFlorestal:
return(new RegistroAtividadeFlorestalBus());
case eCaracterizacao.Aquicultura:
return(new AquiculturaBus());
case eCaracterizacao.Silvicultura:
return(new SilviculturaBus());
case eCaracterizacao.SilviculturaATV:
return(new SilviculturaATVBus());
case eCaracterizacao.InformacaoCorte:
return(new InformacaoCorteBus());
case eCaracterizacao.PulverizacaoProduto:
return(new PulverizacaoProdutoBus());
case eCaracterizacao.PatioLavagem:
return(new PatioLavagemBus());
case eCaracterizacao.UnidadeConsolidacao:
return(new UnidadeConsolidacaoBus());
case eCaracterizacao.UnidadeProducao:
return(new UnidadeProducaoBus());
case eCaracterizacao.BarragemDispensaLicenca:
return(new BarragemDispensaLicencaBus());
default:
return(null);
}
}
public List <CoordenadaAtividade> ObterCoordenadaAtividade(int empreendimentoId, eCaracterizacao caracterizacaoTipo, eTipoGeometria tipoGeo)
{
return(_da.ObterCoordenadas(empreendimentoId, caracterizacaoTipo, tipoGeo));
}
public void CopiarDadosCredenciado(Dependencia dependencia, int empreendimentoInternoID, BancoDeDados banco, BancoDeDados bancoCredenciado)
{
if (banco == null)
{
return;
}
#region Configurar Projeto
//Obter do Credenciado
Cred.ModuloProjetoGeografico.Bussiness.ProjetoGeograficoBus projetoGeoCredBus = new Cred.ModuloProjetoGeografico.Bussiness.ProjetoGeograficoBus();
ProjetoGeografico projetoGeo = projetoGeoCredBus.ObterHistorico(dependencia.DependenciaId, dependencia.DependenciaTid);
eCaracterizacao caracterizacaoTipo = (eCaracterizacao)dependencia.DependenciaCaracterizacao;
int projetoGeoCredenciadoId = projetoGeo.Id;
int empreendimentoCredenciadoId = projetoGeo.EmpreendimentoId;
bool atualizarDependencias = (!Desatualizado(projetoGeo.InternoID, projetoGeo.InternoTID) && !projetoGeo.AlteradoCopiar);
#endregion
if (_validar.CopiarDadosCredenciado(projetoGeo))
{
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
bancoDeDados.IniciarTransacao();
_da.CopiarDadosCredenciado(projetoGeo, empreendimentoInternoID, bancoDeDados);
projetoGeoCredBus.AtualizarInternoIdTid(
empreendimentoCredenciadoId,
projetoGeoCredenciadoId,
(eCaracterizacao)projetoGeo.CaracterizacaoId,
projetoGeo.Id,
GerenciadorTransacao.ObterIDAtual(),
bancoCredenciado);
#region Arquivo
ArquivoBus _busArquivoInterno = new ArquivoBus(eExecutorTipo.Interno);
ArquivoBus _busArquivoCredenciado = new ArquivoBus(eExecutorTipo.Credenciado);
foreach (var item in projetoGeo.Arquivos)
{
Arquivo aux = _busArquivoCredenciado.Obter(item.Id.Value); //Obtém o arquivo completo do diretorio do credenciado(nome, buffer, etc)
aux.Id = 0; //Zera o ID
aux = _busArquivoInterno.SalvarTemp(aux); //salva no diretório temporário
aux = _busArquivoInterno.Copiar(aux); //Copia para o diretório oficial
//Salvar na Oficial
ArquivoDa arquivoDa = new ArquivoDa();
arquivoDa.Salvar(aux, User.FuncionarioId, User.Name, User.Login, (int)eExecutorTipo.Interno, User.FuncionarioTid, bancoDeDados);
item.Id = aux.Id;
}
_da.SalvarArquivosCredenciado(projetoGeo, bancoDeDados);
#endregion
#region Histórico
HistCaract.Historico historico = new HistCaract.Historico();
historico.Gerar(projetoGeo.Id, eHistoricoArtefatoCaracterizacao.projetogeografico, eHistoricoAcao.importar, bancoDeDados);
historico.GerarGeo(projetoGeo.Id, eHistoricoArtefatoCaracterizacao.projetogeografico, eHistoricoAcao.importar, bancoDeDados);
#endregion
#region Dependencias
//Gerencia as dependências
projetoGeo.Dependencias = _caracterizacaoBus.ObterDependenciasAtual(empreendimentoInternoID, caracterizacaoTipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico);
_caracterizacaoBus.Dependencias(new Caracterizacao()
{
Id = projetoGeo.Id,
Tipo = caracterizacaoTipo,
DependenteTipo = eCaracterizacaoDependenciaTipo.ProjetoGeografico,
Dependencias = projetoGeo.Dependencias
}, bancoDeDados);
if (projetoGeo.InternoID > 0)
{
if (atualizarDependencias)
{
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
caracterizacaoBus.AtualizarDependentes(projetoGeo.InternoID, caracterizacaoTipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico, projetoGeo.Tid, bancoDeDados);
}
}
#endregion
bancoDeDados.Commit();
}
}
}
public void AtualizarDependentes(int dependenciaID, eCaracterizacao caracterizacaoTipo, eCaracterizacaoDependenciaTipo eCaracterizacaoDependenciaTipo, string dependenciaTID, BancoDeDados banco = null)
{
_da.AtualizarDependentes(dependenciaID, caracterizacaoTipo, eCaracterizacaoDependenciaTipo, dependenciaTID, banco);
}
public Sobreposicoes ObterGeoSobreposiacao(int id, eCaracterizacao tipo)
{
Sobreposicoes sobreposicoes = new Sobreposicoes();
try
{
sobreposicoes.DataVerificacao = DateTime.Now.ToString("dd/MM/yyyy - HH:mm", CultureInfo.CurrentCulture.DateTimeFormat);
#region Empreendimento
Sobreposicao sobreposicaoEmp = _da.ObterGeoSobreposicaoIdaf(id, tipo);
if (sobreposicaoEmp == null)
{
sobreposicaoEmp = CriarObjSobreposicao(string.Empty);
sobreposicaoEmp.Identificacao = " - ";
}
else
{
sobreposicaoEmp.TipoTexto = SobreposicaoTipo.Single(y => y.Id == (int)sobreposicaoEmp.Tipo).Texto;
}
sobreposicoes.Itens.Add(sobreposicaoEmp);
#endregion
#region Feicoes Geobases
string ATPWkt = _da.ObterWktATP(id, tipo);
string urlGeoBasesWebService = _config.Obter <string>(ConfiguracaoSistema.KeyUrlGeoBasesWebServices);
urlGeoBasesWebService = urlGeoBasesWebService + "/Topologia/Relacao";
if (String.IsNullOrEmpty(ATPWkt))
{
Validacao.Add(Mensagem.ProjetoGeografico.ATPNaoEncontrada);
return(null);
}
//teste
//urlGeoBasesWebService = "http://localhost:33716/Topologia/Relacao";
List <string> feicoes = new List <string>()
{
"HID_BACIA_HIDROGRAFICA", "LIM_TERRA_INDIGENA", "LIM_UNIDADE_PROTECAO_INTEGRAL", "LIM_UNIDADE_CONSERV_NAO_SNUC", "LIM_OUTRAS_UNID_PROTEGIDAS", "LIM_UNIDADE_USO_SUSTENTAVEL"
};
RequestJson request = new RequestJson();
ResponseJsonData <List <FeicaoJson> > responseData = request.Executar <List <FeicaoJson> >(urlGeoBasesWebService, RequestJson.POST, new { feicoes = feicoes, wkt = ATPWkt });
if (responseData.Erros != null && responseData.Erros.Count > 0)
{
responseData.Erros.Insert(0, new Mensagem()
{
Tipo = eTipoMensagem.Erro, Texto = "Erro no WebService GeoBases"
});
Validacao.Erros.AddRange(responseData.Erros);
return(null);
}
Sobreposicao sobreposicao = null;
foreach (var key in feicoes)
{
sobreposicao = CriarObjSobreposicao(key);
if (!responseData.Data.Exists(x => x.Nome == key))
{
sobreposicao.Identificacao = " - ";
sobreposicoes.Itens.Add(sobreposicao);
continue;
}
FeicaoJson feicaoJson = responseData.Data.First(x => x.Nome == key);
List <string> lst = null;
if (!feicaoJson.Geometrias.SelectMany(x => x.Atributos).Any(x => x.Nome == "ADMINISTRACAO"))
{
sobreposicao.Identificacao = String.Join("; ", feicaoJson.Geometrias.SelectMany(x => x.Atributos).Select(x => x.Valor).ToArray());
}
else
{
lst = feicaoJson.Geometrias
.Select(x => String.Format("{0} - {1}",
x.Atributos.Single(y => y.Nome == "Nome").Valor,
x.Atributos.Single(y => y.Nome == "ADMINISTRACAO").Valor)).ToList();
sobreposicao.Identificacao = String.Join("; ", lst.ToArray());
}
sobreposicoes.Itens.Add(sobreposicao);
}
#endregion
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(sobreposicoes);
}
public void CopiarDadosInstitucional(int empreendimentoID, eCaracterizacao caracterizacaoTipo, int projetoDigitalID, DesassociarDependencias desassociarDependencias)
{
try
{
EmpreendimentoCaracterizacao empreendimento = ObterEmpreendimentoSimplificado(empreendimentoID);
ProjetoGeograficoBus projetoGeograficoBus = new ProjetoGeograficoBus();
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(UsuarioCredenciado))
{
bancoDeDados.IniciarTransacao();
if (caracterizacaoTipo != eCaracterizacao.UnidadeProducao && caracterizacaoTipo != eCaracterizacao.UnidadeConsolidacao && caracterizacaoTipo != eCaracterizacao.BarragemDispensaLicenca)
{
projetoGeograficoBus.CopiarDadosInstitucional(empreendimentoID, empreendimento.InternoID, (eCaracterizacao)caracterizacaoTipo, bancoDeDados);
}
if (!Validacao.EhValido)
{
bancoDeDados.Rollback();
return;
}
ICaracterizacaoBus caracterizacaoBus = CaracterizacaoBusFactory.Criar(caracterizacaoTipo);
if (caracterizacaoBus == null)
{
Validacao.Add(eTipoMensagem.Erro, "Caracterizacao Bus não criada");
}
caracterizacaoBus.CopiarDadosInstitucional(empreendimentoID, empreendimento.InternoID, bancoDeDados);
if (!Validacao.EhValido)
{
bancoDeDados.Rollback();
return;
}
#region Alterar Projeto Digital
ProjetoDigital projetoDigital = new ProjetoDigital();
projetoDigital.Id = projetoDigitalID;
projetoDigital.EmpreendimentoId = empreendimentoID;
projetoDigital.Dependencias.Add(new Dependencia()
{
DependenciaCaracterizacao = (int)caracterizacaoTipo
});
desassociarDependencias(projetoDigital, bancoDeDados);
#endregion
if (!Validacao.EhValido)
{
bancoDeDados.Rollback();
}
Validacao.Erros.Clear();
Validacao.Add(Mensagem.ProjetoDigital.CopiarCaracterizacao);
bancoDeDados.Commit();
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
}
