public List <CaracterizacaoLst> ObterCaracterizacoes(int empreendimento)
{
List <CaracterizacaoLst> caracterizacoesRetorno = new List <CaracterizacaoLst>();
List <CaracterizacaoLst> caracterizacoes = _caracterizacaoConfig.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes);
caracterizacoes = caracterizacoes.Where(x => x.Id == (int)eCaracterizacao.ExploracaoFlorestal || x.Id == (int)eCaracterizacao.QueimaControlada || x.Id == (int)eCaracterizacao.Silvicultura).ToList();
int caracterizacao = 0;
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
foreach (CaracterizacaoLst item in caracterizacoes)
{
caracterizacao = caracterizacaoBus.Existe(empreendimento, (eCaracterizacao)item.Id);
if (caracterizacao <= 0)
{
continue;
}
List <Dependencia> dependencias = caracterizacaoBus.ObterDependencias(caracterizacao, (eCaracterizacao)item.Id, eCaracterizacaoDependenciaTipo.Caracterizacao);
string retorno = caracterizacaoValidar.DependenciasAlteradas(empreendimento, item.Id, eCaracterizacaoDependenciaTipo.Caracterizacao, dependencias);
if (!string.IsNullOrEmpty(retorno))
{
continue;
}
caracterizacoesRetorno.Add(item);
}
return(caracterizacoesRetorno);
}
public bool Excluir(int empreendimento, BancoDeDados banco = null, bool validarDependencias = true)
{
try
{
if (!_caracterizacaoValidar.Basicas(empreendimento))
{
return(Validacao.EhValido);
}
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco, UsuarioCredenciado))
{
bancoDeDados.IniciarTransacao();
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
caracterizacaoBus.ConfigurarEtapaExcluirCaracterizacao(empreendimento, bancoDeDados);
_da.Excluir(empreendimento, bancoDeDados);
Validacao.Add(Mensagem.UnidadeProducao.ExcluidoSucesso);
bancoDeDados.Commit();
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(Validacao.EhValido);
}
public UnidadeProducao ObterPorEmpreendimento(int empreendimentoId, int projetoDigitalId = 0, bool simplificado = false, BancoDeDados banco = null)
{
UnidadeProducao caracterizacao = null;
try
{
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
List <Caracterizacao> caracterizacoesAssociadas = caracterizacaoBus.ObterCaracterizacoesAssociadasProjetoDigital(projetoDigitalId).Where(x => x.Tipo == eCaracterizacao.UnidadeProducao).ToList();
if (caracterizacoesAssociadas != null && caracterizacoesAssociadas.Count > 0)
{
caracterizacao = ObterHistorico(caracterizacoesAssociadas.FirstOrDefault().Id, caracterizacoesAssociadas.FirstOrDefault().Tid);
}
else
{
caracterizacao = _da.ObterPorEmpreendimento(empreendimentoId, simplificado);
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
internal bool Salvar(ProjetoGeografico projeto)
{
if (_da.ExisteProjetoGeografico(projeto.EmpreendimentoId, projeto.CaracterizacaoId) != projeto.Id)
{
Validacao.Add(Mensagem.ProjetoGeografico.JaExisteCadastro);
return(false);
}
if (projeto.NivelPrecisaoId <= 0)
{
Validacao.Add(Mensagem.ProjetoGeografico.NivelPrecisaoObrigatorio);
return(false);
}
if (projeto.MaiorX <= 0 || projeto.MaiorY <= 0 || projeto.MenorX <= 0 || projeto.MenorY <= 0)
{
Validacao.Add(Mensagem.ProjetoGeografico.AreaDeAbrangenciaObrigatorio);
return(false);
}
if (projeto.MecanismoElaboracaoId == 0)
{
Validacao.Add(Mensagem.ProjetoGeografico.MecanismoObrigatorio);
return(false);
}
CaracterizacaoBus _busCaracterizacao = new CaracterizacaoBus();
if (!_busCaracterizacao.ExisteEmpreendimento(projeto.EmpreendimentoId))
{
Validacao.Add(Mensagem.ProjetoGeografico.EmpreendimentoInexistente);
}
return(Validacao.EhValido);
}
public void AssociarDependencias(ProjetoDigital projetoDigital, BancoDeDados banco = null)
{
try
{
#region Configurar
List <Caracterizacao> lista = new List <Caracterizacao>();
lista.Add(new Caracterizacao()
{
Tipo = (eCaracterizacao)projetoDigital.Dependencias.First().DependenciaCaracterizacao
});
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
lista = caracterizacaoBus.ObterCaracterizacoesAtuais(projetoDigital.EmpreendimentoId.GetValueOrDefault(), lista);
Caracterizacao aux = lista.First();
projetoDigital.Dependencias.Clear();
projetoDigital.Dependencias.Add(new Dependencia()
{
DependenciaTipo = (int)eCaracterizacaoDependenciaTipo.Caracterizacao,
DependenciaCaracterizacao = (int)aux.Tipo,
DependenciaId = aux.Id,
DependenciaTid = aux.Tid
});
if (aux.ProjetoId > 0)
{
projetoDigital.Dependencias.Add(new Dependencia()
{
DependenciaTipo = (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico,
DependenciaCaracterizacao = (int)aux.Tipo,
DependenciaId = aux.ProjetoId,
DependenciaTid = aux.ProjetoTid
});
}
#endregion
if (_validar.AssociarDependencias(projetoDigital))
{
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco, UsuarioCredenciado))
{
bancoDeDados.IniciarTransacao();
_da.AssociarDependencias(projetoDigital, bancoDeDados);
AlterarEtapa(projetoDigital.Id, eProjetoDigitalEtapa.Caracterizacao, bancoDeDados);
Validacao.Add(Mensagem.ProjetoDigital.AssociadaProjetoDigital);
bancoDeDados.Commit();
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
}
public bool Salvar(IEspecificidade especificidade)
{
CertificadoRegistroAtividadeFlorestal esp = especificidade as CertificadoRegistroAtividadeFlorestal;
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
List <Caracterizacao> caracterizacoes = caracterizacaoBus.ObterCaracterizacoesEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
RequerimentoAtividade(esp, jaAssociado: false); //Validação de Atividade já associada feita a seguir
ValidarTituloUnicoPorEmpreendimentoAtividade(esp);
Destinatario(especificidade.ProtocoloReq.Id, esp.Destinatario, "Certificado_Destinatario");
int idCaracterizacao = caracterizacaoBus.Existe(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.RegistroAtividadeFlorestal);
if (idCaracterizacao > 0)
{
ICaracterizacaoBus busCaract = CaracterizacaoBusFactory.Criar(eCaracterizacao.RegistroAtividadeFlorestal);
bool isPossui = false;
busCaract.ObterAtividadesCaracterizacao(especificidade.Titulo.EmpreendimentoId.Value).ForEach(x =>
{
if (esp.Atividades[0].Id == x)
{
isPossui = true;
return;
}
});
if (!isPossui)
{
Validacao.Add(Mensagem.CertificadoRegistroAtividadeFlorestalMsg.CaracterizacaoAtividadeInexistente);
}
}
else
{
Validacao.Add(Mensagem.CertificadoRegistroAtividadeFlorestalMsg.RegistroAtividadeFlorestalInexistente);
}
#region Campos da especifícidade
if (string.IsNullOrWhiteSpace(esp.Vias))
{
Validacao.Add(Mensagem.CertificadoRegistroAtividadeFlorestalMsg.ViaObrigatorio);
}
else if (esp.Vias == "0")
{
Validacao.Add(Mensagem.CertificadoRegistroAtividadeFlorestalMsg.ViaObrigatorio);
}
if (string.IsNullOrWhiteSpace(esp.AnoExercicio))
{
Validacao.Add(Mensagem.CertificadoRegistroAtividadeFlorestalMsg.AnoExercicioObrigatorio);
}
#endregion
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
LaudoVistoriaFlorestal esp = especificidade as LaudoVistoriaFlorestal;
RequerimentoAtividade(esp, solicitado: false);
Destinatario(especificidade.ProtocoloReq.Id, esp.Destinatario, "Laudo_Destinatario");
ValidacoesGenericasBus.DataMensagem(esp.DataVistoria, "Laudo_DataVistoria_DataTexto", "vistoria");
if (String.IsNullOrWhiteSpace(esp.Objetivo))
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ObjetivoObrigatorio);
}
if (esp.Caracterizacao <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.CaracterizacaoObrigatoria);
}
else
{
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
int caracterizacao = caracterizacaoBus.Existe(esp.Titulo.EmpreendimentoId.GetValueOrDefault(), (eCaracterizacao)esp.Caracterizacao);
if (caracterizacao <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.CaracterizacaoCadastrada);
}
}
if (String.IsNullOrWhiteSpace(esp.Consideracao))
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ConsideracoesObrigatorio);
}
if (esp.Titulo.Modelo == "12") //Laudo de Vistoria de Exploração Florestal
{
if (esp.FavoravelObrigatorio && String.IsNullOrWhiteSpace(esp.ParecerDescricao))
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ParecerTecnicoDescricaoObrigatorio);
}
if (esp.DesfavoravelObrigatorio && String.IsNullOrWhiteSpace(esp.ParecerDescricaoDesfavoravel))
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ParecerTecnicoDescricaoDesfavoravelObrigatorio);
}
}
else if (String.IsNullOrWhiteSpace(esp.ParecerDescricao))
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ParecerTecnicoDescricaoObrigatorio);
}
if (esp.Conclusao <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ConclusaoObrigatoria);
}
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
AutorizacaoQueimaControlada esp = especificidade as AutorizacaoQueimaControlada;
EspecificidadeDa _da = new EspecificidadeDa();
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
List <Caracterizacao> caracterizacoes = caracterizacaoBus.ObterCaracterizacoesEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
List <Dependencia> dependencias = new List <Dependencia>();
String caracterizacoesAlteradas = String.Empty;
int idCaracterizacao;
RequerimentoAtividade(esp, false, true);
Destinatario(especificidade.ProtocoloReq.Id, esp.Destinatario, "Autorizacao_Destinatario");
if ((esp.TitulosAssociado.FirstOrDefault() ?? new TituloAssociadoEsp()).Id <= 0)
{
Validacao.Add(Mensagem.AutorizacaoQueimaControlada.LaudoVistoriaObrigatorio);
}
else if (_daEspecificidade.ObterTituloAssociado(esp.TitulosAssociado.FirstOrDefault().Id).Situacao != (int)eTituloSituacao.Concluido)
{
Validacao.Add(Mensagem.AutorizacaoQueimaControlada.LaudoVIstoriaDeveEstarConcluiddo);
}
idCaracterizacao = caracterizacaoBus.Existe(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.Dominialidade);
if (idCaracterizacao > 0)
{
dependencias = caracterizacaoBus.ObterDependencias(idCaracterizacao, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
if (caracterizacaoValidar.DependenciasAlteradas(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), (int)eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao, dependencias) != String.Empty)
{
Validacao.Add(Mensagem.AutorizacaoQueimaControlada.CaracterizacaoDeveEstarValida(caracterizacoes.Single(x => x.Tipo == eCaracterizacao.Dominialidade).Nome));
}
}
else
{
Validacao.Add(Mensagem.AutorizacaoQueimaControlada.DominialidadeInexistente);
}
idCaracterizacao = caracterizacaoBus.Existe(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.QueimaControlada);
if (idCaracterizacao > 0)
{
dependencias = caracterizacaoBus.ObterDependencias(idCaracterizacao, eCaracterizacao.QueimaControlada, eCaracterizacaoDependenciaTipo.Caracterizacao);
if (caracterizacaoValidar.DependenciasAlteradas(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), (int)eCaracterizacao.QueimaControlada, eCaracterizacaoDependenciaTipo.Caracterizacao, dependencias) != String.Empty)
{
Validacao.Add(Mensagem.AutorizacaoQueimaControlada.CaracterizacaoDeveEstarValida(caracterizacoes.Single(x => x.Tipo == eCaracterizacao.QueimaControlada).Nome));
}
}
else
{
Validacao.Add(Mensagem.AutorizacaoQueimaControlada.QueimaInexistente);
}
if (caracterizacoesAlteradas != String.Empty)
{
Validacao.Add(Mensagem.Caracterizacao.CaracterizacaoAlterada);
}
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
LaudoVistoriaFundiaria esp = especificidade as LaudoVistoriaFundiaria;
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
LaudoVistoriaFundiariaBus busLaudo = new LaudoVistoriaFundiariaBus();
List <Dependencia> dependencias = new List <Dependencia>();
//Genéricas
RequerimentoAtividade(esp, false, true);
if (esp.Destinatario <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFundiariaMsg.DestinatarioObrigatorio);
}
if (esp.RegularizacaoDominios.Count <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFundiariaMsg.RegularizacaoDominioObrigatorio);
}
int idCaracterizacao = caracterizacaoBus.Existe(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.RegularizacaoFundiaria);
if (idCaracterizacao > 0)
{
dependencias = caracterizacaoBus.ObterDependencias(idCaracterizacao, eCaracterizacao.RegularizacaoFundiaria, eCaracterizacaoDependenciaTipo.Caracterizacao);
if (caracterizacaoValidar.DependenciasAlteradas(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), (int)eCaracterizacao.RegularizacaoFundiaria, eCaracterizacaoDependenciaTipo.Caracterizacao, dependencias) != String.Empty)
{
Validacao.Add(Mensagem.LaudoVistoriaFundiariaMsg.RegularizacaoFundiariaInvalida);
}
}
else
{
Validacao.Add(Mensagem.LaudoVistoriaFundiariaMsg.RegularizacaoFundiariaObrigatorio);
}
#region Regularizacao fundiaria
List <Int32> idsPossesRegularizacao = busLaudo.ObterPossesRegularizacao(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()).Select(x => Convert.ToInt32(x.Id)).ToList();
esp.RegularizacaoDominios.ForEach(x =>
{
if (!idsPossesRegularizacao.Contains(x.DominioId))
{
Validacao.Add(Mensagem.LaudoVistoriaFundiariaMsg.RegularizacaoDominioInexistente);
}
});
#endregion
ValidacoesGenericasBus.DataMensagem(esp.DataVistoria, "Laudo_DataVistoria_DataTexto", "vistoria");
if (busLaudo.ExistePecaTecnica(esp.Atividades.First().Id, esp.ProtocoloReq.Id) <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFundiariaMsg.PecaTecnicaObrigatorio(esp.Atividades.First().NomeAtividade));
}
return(Validacao.EhValido);
}
public ProjetoDigitalCredenciadoValidar(string esquema = null)
{
_configSys = new GerenciadorConfiguracao <ConfiguracaoSistema>(new ConfiguracaoSistema());
_da = new ProjetoDigitalCredenciadoDa(UsuarioCredenciado);
_requerimentoCredenciadoValidar = new RequerimentoCredenciadoValidar();
_busCaracterizacao = new CaracterizacaoBus();
_validarCaracterizacao = new CaracterizacaoValidar();
_internoBus = new CaracterizacaoInternoBus();
}
public ProjetoGeograficoBus(ProjetoGeograficoValidar validar)
{
_da = new ProjetoGeograficoDa();
_validar = new ProjetoGeograficoValidar();
_caracterizacaoBus = new CaracterizacaoBus();
_config = new ConfiguracaoSistema();
_configPGeo = new GerenciadorConfiguracao <ConfiguracaoProjetoGeo>(new ConfiguracaoProjetoGeo());
_caracterizacaoConfig = new GerenciadorConfiguracao <ConfiguracaoCaracterizacao>(new ConfiguracaoCaracterizacao());
_gerenciador = new GerenciadorArquivo(_config.DiretorioOrtoFotoMosaico, null);
}
public bool ExisteEmpreendimento(int id)
{
CaracterizacaoBus _busCaracterizacao = new CaracterizacaoBus();
if (!_busCaracterizacao.ExisteEmpreendimento(id))
{
Validacao.Add(Mensagem.ProjetoGeografico.EmpreendimentoNaoCadastrao);
}
return(Validacao.EhValido);
}
public CARSolicitacaoValidar()
{
_requerimentoValidar = new RequerimentoCredenciadoValidar();
_busCaracterizacao = new CaracterizacaoBus();
_busProjetoGeografico = new ProjetoGeograficoBus();
_busProjetoDigital = new ProjetoDigitalCredenciadoBus();
_busRequerimento = new RequerimentoCredenciadoBus();
_daCarSolicitacao = new CARSolicitacaoDa();
_carSolicitacaoInternoDa = new CARSolicitacaoInternoDa();
}
public RegularizacaoFundiariaBus(RegularizacaoFundiariaValidar validar)
{
_configCaracterizacao = new GerenciadorConfiguracao <ConfiguracaoCaracterizacao>(new ConfiguracaoCaracterizacao());
_validar = validar;
_da = new RegularizacaoFundiariaDa();
_busCaracterizacao = new CaracterizacaoBus();
_busDominialidade = new DominialidadeBus();
_caracterizacaoValidar = new CaracterizacaoValidar();
}
public bool Salvar(IEspecificidade especificidade)
{
#region Variáveis
OutrosInformacaoCorteDa _da = new OutrosInformacaoCorteDa();
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
List <Dependencia> dependencias = new List <Dependencia>();
OutrosInformacaoCorte esp = especificidade as OutrosInformacaoCorte;
List <Caracterizacao> caracterizacoes = caracterizacaoBus.ObterCaracterizacoesEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
int idCaracterizacao;
#endregion
RequerimentoAtividade(esp);
Destinatario(esp.ProtocoloReq.Id, esp.Destinatario, "Outros_Destinatarios");
// Atividade Informação de corte
if (esp.Atividades[0].Id != ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.InformacaoDeCorte))
{
Validacao.Add(Mensagem.OutrosInformacaoCorte.AtividadeInvalida(esp.Atividades[0].NomeAtividade));
}
idCaracterizacao = caracterizacaoBus.Existe(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.InformacaoCorte);
if (idCaracterizacao > 0)
{
dependencias = caracterizacaoBus.ObterDependencias(idCaracterizacao, eCaracterizacao.InformacaoCorte, eCaracterizacaoDependenciaTipo.Caracterizacao);
if (caracterizacaoValidar.DependenciasAlteradas(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), (int)eCaracterizacao.InformacaoCorte, eCaracterizacaoDependenciaTipo.Caracterizacao, dependencias) != String.Empty)
{
Validacao.Add(Mensagem.OutrosInformacaoCorte.CaracterizacaoValida(caracterizacoes.Single(x => x.Tipo == eCaracterizacao.InformacaoCorte).Nome));
}
}
else
{
Validacao.Add(Mensagem.OutrosInformacaoCorte.CaracterizacaoCadastrada);
}
if (esp.InformacaoCorte == 0)
{
Validacao.Add(Mensagem.OutrosInformacaoCorte.InformacaoCorteObrigatorio);
}
else if (!_da.IsInformacaoCorteCadastrado(esp.InformacaoCorte))
{
Validacao.Add(Mensagem.OutrosInformacaoCorte.InformacaoCorteInexistente);
}
else if (_da.IsInformacaoCorteAssociado(esp.InformacaoCorte, esp.Id))
{
Validacao.Add(Mensagem.OutrosInformacaoCorte.InformacaoCorteAssociado);
}
return(Validacao.EhValido);
}
internal bool Finalizar(ProjetoGeografico projeto)
{
CaracterizacaoBus _busCaracterizacao = new CaracterizacaoBus();
if (!_busCaracterizacao.ExisteEmpreendimento(projeto.EmpreendimentoId))
{
Validacao.Add(Mensagem.ProjetoGeografico.EmpreendimentoInexistente);
return(false);
}
if (_da.ObterSituacaoProjetoGeografico(projeto.Id) == (int)eProjetoGeograficoSituacao.Finalizado)
{
Validacao.Add(Mensagem.ProjetoGeografico.SituacaoProjetoFinalizado);
return(false);
}
if (!_da.VerificarProjetoGeograficoProcessado(projeto.Id, (eCaracterizacao)projeto.CaracterizacaoId))
{
Validacao.Add(Mensagem.ProjetoGeografico.SituacaoDeveSerProcessado);
return(false);
}
if (projeto.Sobreposicoes == null || projeto.Sobreposicoes.Itens == null || projeto.Sobreposicoes.Itens.Count == 0 || !ValidarDataVerificacao(projeto.Sobreposicoes))
{
Validacao.Add(Mensagem.ProjetoGeografico.VerificarSobreposicao);
}
List <string> auxiliar = _da.VerificarExcluirDominios(projeto.EmpreendimentoId);
if (auxiliar != null && auxiliar.Count > 0)
{
foreach (var item in auxiliar)
{
Validacao.Add(Mensagem.Dominialidade.DominioAssossiadoReserva(item));
}
}
if (projeto.InternoID > 0)
{
List <ReservaLegal> reservasInternoRelacionadasCompensacao = _dominialidadeInternoDa.ObterRLsCompensacao(projeto.InternoID);
List <ReservaLegal> reservarProcessadas = _dominialidadeDa.ObterRLGeoProcessadas(projeto.Id);
reservasInternoRelacionadasCompensacao.ForEach(reservaInterno => {
if (!reservarProcessadas.Exists(rp => reservaInterno.Identificacao == rp.Identificacao))
{
Validacao.Add(Mensagem.Dominialidade.NaoPermitidoExcluirReserva(reservaInterno.Identificacao));
}
});
}
return(Validacao.EhValido);
}
public bool ImportarProjetoDigital(int analiseId, int projetoDigitalId)
{
try
{
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
bancoDeDados.IniciarTransacao();
using (BancoDeDados bancoCredenciado = BancoDeDados.ObterInstancia(EsquemaBancoCredenciado))
{
bancoCredenciado.IniciarTransacao();
AnaliseItem analise = Obter(analiseId);
analise.Situacao = (int)eAnaliseSituacao.Finalizado;
if (_validar.Analise(analise))
{
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
caracterizacaoBus.CopiarDadosCredenciado(projetoDigitalId, bancoDeDados, bancoCredenciado);
_da.AlterarSituacao(analise, bancoDeDados);
ProjetoDigitalCredenciadoBus projetoDigitalCredenciadoBus = new ProjetoDigitalCredenciadoBus();
projetoDigitalCredenciadoBus.AlterarEtapaTemporario(projetoDigitalId, eProjetoDigitalEtapaImportacao.Finalizado, bancoDeDados);
if (!Validacao.EhValido)
{
bancoDeDados.Rollback();
bancoCredenciado.Rollback();
return(false);
}
}
bancoCredenciado.Commit();
}
bancoDeDados.Commit();
}
return(true);
}
catch (Exception e)
{
Validacao.AddErro(e);
}
return(false);
}
public bool CopiarDadosInstitucional(int empreendimentoID, int empreendimentoInternoID, BancoDeDados banco)
{
if (banco == null)
{
return(false);
}
if (_validar == null)
{
_validar = new UnidadeProducaoValidar();
}
#region Configurar Caracterização
UnidadeProducaoInternoBus unidadeConsolidacaoInternoBus = new UnidadeProducaoInternoBus();
UnidadeProducao caracterizacao = unidadeConsolidacaoInternoBus.ObterPorEmpreendimento(empreendimentoInternoID);
caracterizacao.Empreendimento.Id = empreendimentoID;
caracterizacao.InternoID = caracterizacao.Id;
caracterizacao.InternoTID = caracterizacao.Tid;
caracterizacao.UnidadesProducao.SelectMany(u => u.Produtores).ToList().ForEach(p => { p.IdRelacionamento = 0; });
caracterizacao.UnidadesProducao.SelectMany(u => u.ResponsaveisTecnicos).ToList().ForEach(r => { r.IdRelacionamento = 0; });
//Remove UPs nao relacionadas.
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
CredenciadoPessoa credenciado = caracterizacaoBus.ObterCredenciado(User.FuncionarioId, true);
//REMOVIDO FILTRO QUE IMPORTAVA APENAS UP's VINCULADAS AO RESPONSAVEL TECNICO
//caracterizacao.UnidadesProducao.RemoveAll(x => !x.ResponsaveisTecnicos.Any(y => y.CpfCnpj == credenciado.Pessoa.CPFCNPJ));
#endregion
if (_validar.CopiarDadosInstitucional(caracterizacao))
{
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco, UsuarioCredenciado))
{
bancoDeDados.IniciarTransacao();
//Setar ID do credenciado
caracterizacao.Id = ObterPorEmpreendimento(empreendimentoID, simplificado: true, banco: bancoDeDados).Id;
_da.CopiarDadosInstitucional(caracterizacao, bancoDeDados);
bancoDeDados.Commit();
}
}
return(Validacao.EhValido);
}
internal bool Refazer(ProjetoGeografico projeto)
{
CaracterizacaoBus _busCaracterizacao = new CaracterizacaoBus();
if (!_busCaracterizacao.ExisteEmpreendimento(projeto.EmpreendimentoId))
{
Validacao.Add(Mensagem.ProjetoGeografico.EmpreendimentoInexistente);
}
if (_da.ExisteProjetoGeografico(projeto.EmpreendimentoId, projeto.CaracterizacaoId, true) <= 0)
{
Validacao.Add(Mensagem.ProjetoGeografico.SituacaoProjetoDeveSerFinalizar);
}
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
AutorizacaoExploracaoFlorestal esp = especificidade as AutorizacaoExploracaoFlorestal;
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
List <Caracterizacao> caracterizacoes = caracterizacaoBus.ObterCaracterizacoesEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
List <Dependencia> dependencias = new List <Dependencia>();
String caracterizacoesAlteradas = String.Empty;
int idCaracterizacao;
RequerimentoAtividade(esp, solicitado: false, jaAssociado: false, atividadeAndamento: false);
if (!String.IsNullOrWhiteSpace(esp.Observacao) && esp.Observacao.Length > 500)
{
Validacao.Add(Mensagem.AutorizacaoExploracaoFlorestal.ObservacaoMuitoGrande);
}
Destinatario(especificidade.ProtocoloReq.Id, esp.Destinatario, "Autorizacao_Destinatario");
if ((esp.TitulosAssociado.FirstOrDefault() ?? new TituloAssociadoEsp()).Id <= 0)
{
Validacao.Add(Mensagem.AutorizacaoExploracaoFlorestal.LaudoVistoriaObrigatorio);
}
else
{
var situacaoLaudo = _daEspecificidade.ObterTituloAssociado(esp.TitulosAssociado.FirstOrDefault().Id).Situacao;
if (situacaoLaudo != (int)eTituloSituacao.Concluido && situacaoLaudo != (int)eTituloSituacao.Prorrogado)
{
Validacao.Add(Mensagem.AutorizacaoExploracaoFlorestal.LaudoVistoriaDeveEstarConcluidoOuProrrogado);
}
}
idCaracterizacao = caracterizacaoBus.Existe(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.ExploracaoFlorestal);
if (idCaracterizacao == 0)
{
Validacao.Add(Mensagem.AutorizacaoExploracaoFlorestal.ExploracaoInexistente);
}
if (caracterizacoesAlteradas != String.Empty)
{
Validacao.Add(Mensagem.Caracterizacao.CaracterizacaoAlterada);
}
return(Validacao.EhValido);
}
public bool Finalizar(ProjetoGeografico projeto)
{
CaracterizacaoBus _busCaracterizacao = new CaracterizacaoBus();
if (!_busCaracterizacao.ExisteEmpreendimento(projeto.EmpreendimentoId))
{
Validacao.Add(Mensagem.ProjetoGeografico.EmpreendimentoInexistente);
return(false);
}
if (_da.ObterSituacaoProjetoGeografico(projeto.Id) == (int)eProjetoGeograficoSituacao.Finalizado)
{
Validacao.Add(Mensagem.ProjetoGeografico.SituacaoProjetoFinalizado);
return(false);
}
if (!_da.VerificarProjetoGeograficoProcessado(projeto.Id, (eCaracterizacao)projeto.CaracterizacaoId))
{
Validacao.Add(Mensagem.ProjetoGeografico.SituacaoDeveSerProcessado);
return(false);
}
if (projeto.Sobreposicoes == null || projeto.Sobreposicoes.Itens == null || projeto.Sobreposicoes.Itens.Count == 0 ||
(!ValidarDataVerificacao(projeto.Sobreposicoes) && projeto.CaracterizacaoId != (int)eCaracterizacao.ExploracaoFlorestal))
{
Validacao.Add(Mensagem.ProjetoGeografico.VerificarSobreposicao);
}
if (projeto.CaracterizacaoId == (int)eCaracterizacao.Dominialidade)
{
List <string> auxiliar = _da.VerificarExcluirDominios(projeto.EmpreendimentoId);
if (auxiliar != null && auxiliar.Count > 0)
{
foreach (var item in auxiliar)
{
Validacao.Add(Mensagem.Dominialidade.DominioAssossiadoReserva(item));
}
}
}
return(Validacao.EhValido);
}
public bool Excluir(int empreendimento, BancoDeDados banco = null, bool validarDependencias = true)
{
try
{
if (!_caracterizacaoValidar.Basicas(empreendimento))
{
return(Validacao.EhValido);
}
if (validarDependencias && !_caracterizacaoValidar.DependenciasExcluir(empreendimento, eCaracterizacao.BarragemDispensaLicenca, eCaracterizacaoDependenciaTipo.Caracterizacao))
{
return(Validacao.EhValido);
}
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco, EsquemaCredenciadoBanco))
{
bancoDeDados.IniciarTransacao();
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
caracterizacaoBus.ConfigurarEtapaExcluirCaracterizacao(empreendimento, bancoDeDados);
_da.Excluir(empreendimento, bancoDeDados);
Validacao.Add(Mensagem.BarragemDispensaLicenca.Excluir);
bancoDeDados.Commit();
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
LicencaOperacaoFomento esp = especificidade as LicencaOperacaoFomento;
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
List <Caracterizacao> caracterizacoes = caracterizacaoBus.ObterCaracterizacoesEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
RequerimentoAtividade(esp, faseAnterior: false);
int idCaracterizacao = caracterizacaoBus.Existe(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.SilviculturaPPFF);
if (idCaracterizacao > 0)
{
ICaracterizacaoBus busCaract = CaracterizacaoBusFactory.Criar(eCaracterizacao.SilviculturaPPFF);
bool isPossui = false;
busCaract.ObterAtividadesCaracterizacao(especificidade.Titulo.EmpreendimentoId.Value).ForEach(x =>
{
if (esp.Atividades[0].Id == x)
{
isPossui = true;
return;
}
});
if (!isPossui)
{
Validacao.Add(Mensagem.LicencaOperacaoFomentoMsg.CaracterizacaoAtividadeInexistente);
}
}
else
{
Validacao.Add(Mensagem.LicencaOperacaoFomentoMsg.SilviculturaPPFFInexistente);
}
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
LaudoVistoriaFomentoFlorestal esp = especificidade as LaudoVistoriaFomentoFlorestal;
RequerimentoAtividade(esp, false, true);
Destinatario(especificidade.ProtocoloReq.Id, esp.Destinatario, "Laudo_Destinatario");
ValidacoesGenericasBus.DataMensagem(esp.DataVistoria, "Laudo_DataVistoria_DataTexto", "vistoria");
if (String.IsNullOrWhiteSpace(esp.Objetivo))
{
Validacao.Add(Mensagem.LaudoVistoriaFomentoFlorestal.ObjetivoObrigatorio);
}
if (String.IsNullOrWhiteSpace(esp.Consideracoes))
{
Validacao.Add(Mensagem.LaudoVistoriaFomentoFlorestal.ConsideracoesObrigatorio);
}
if (String.IsNullOrWhiteSpace(esp.DescricaoParecer))
{
Validacao.Add(Mensagem.LaudoVistoriaFomentoFlorestal.ParecerTecnicoObrigatorio);
}
if (esp.ConclusaoTipo <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFomentoFlorestal.ConclusaoObrigatoria);
}
#region Caracterizacao
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
int caracterizacao = caracterizacaoBus.Existe(esp.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.SilviculturaATV);
if (caracterizacao <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFomentoFlorestal.CaracterizacaoCadastrada);
}
else
{
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
List <Dependencia> dependencias = caracterizacaoBus.ObterDependencias(caracterizacao, eCaracterizacao.SilviculturaATV, eCaracterizacaoDependenciaTipo.Caracterizacao);
string retorno = caracterizacaoValidar.DependenciasAlteradas(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(),
(int)eCaracterizacao.SilviculturaATV,
eCaracterizacaoDependenciaTipo.Caracterizacao,
dependencias);
if (!string.IsNullOrEmpty(retorno))
{
List <CaracterizacaoLst> caracterizacoes = _caracterizacaoConfig.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes);
Validacao.Add(Mensagem.LaudoVistoriaFomentoFlorestal.CaracterizacaoInvalida(caracterizacoes.SingleOrDefault(x => x.Id == (int)eCaracterizacao.SilviculturaATV).Texto));
}
}
#endregion
#region Atividade
foreach (var atividade in esp.Atividades)
{
if (atividade.Id != 0 && atividade.Id != ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.ImplantacaoAtividadeSilviculturaReferenteAoFomentoFlorestal))
{
List <ProcessoAtividadeItem> atividades = _atividadeConfig.Obter <List <ProcessoAtividadeItem> >(ConfiguracaoProcesso.KeyAtividadesProcesso);
Validacao.Add(Mensagem.LaudoVistoriaFomentoFlorestal.AtividadeInvalida(atividades.SingleOrDefault(x => x.Id == atividade.Id).Texto));
}
}
#endregion
return(Validacao.EhValido);
}
public bool CopiarDadosCredenciado(Dependencia dependencia, int empreendimentoInternoId, BancoDeDados banco, BancoDeDados bancoCredenciado)
{
if (banco == null)
{
return(false);
}
if (_validar == null)
{
_validar = new DominialidadeValidar();
}
#region Configurar Caracterização
DominialidadeCred.Business.DominialidadeBus dominialidadeCredBus = new DominialidadeCred.Business.DominialidadeBus();
Dominialidade caracterizacao = dominialidadeCredBus.ObterHistorico(dependencia.DependenciaId, dependencia.DependenciaTid);
int dominialidadeCredenciadoId = dependencia.DependenciaId;
int empreendimentoCredenciadoId = caracterizacao.EmpreendimentoId;
caracterizacao.EmpreendimentoId = empreendimentoInternoId;
caracterizacao.CredenciadoID = caracterizacao.Id;
caracterizacao.Id = 0;
caracterizacao.Tid = string.Empty;
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.CopiarDadosCredenciado(caracterizacao))
{
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
bancoDeDados.IniciarTransacao();
//Setar ID
caracterizacao.Id = ObterPorEmpreendimento(empreendimentoInternoId, simplificado: true, banco: bancoDeDados).Id;
_da.CopiarDadosCredenciado(caracterizacao, bancoDeDados);
dominialidadeCredBus.AtualizarInternoIdTid(empreendimentoCredenciadoId, dominialidadeCredenciadoId, caracterizacao.Id, GerenciadorTransacao.ObterIDAtual(), bancoCredenciado);
#region Dependencias
//Gerencia as dependências da caracterização
caracterizacao.Dependencias = _busCaracterizacao.ObterDependenciasAtual(empreendimentoInternoId, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
_busCaracterizacao.Dependencias(new Caracterizacao()
{
Id = caracterizacao.Id,
Tipo = eCaracterizacao.Dominialidade,
DependenteTipo = eCaracterizacaoDependenciaTipo.Caracterizacao,
Dependencias = caracterizacao.Dependencias
}, bancoDeDados);
if (caracterizacao.InternoID > 0)
{
if (!Desatualizado(caracterizacao.InternoID, caracterizacao.InternoTID) && !caracterizacao.AlteradoCopiar)
{
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
caracterizacaoBus.AtualizarDependentes(caracterizacao.InternoID, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao, caracterizacao.Tid, bancoDeDados);
}
}
#endregion
bancoDeDados.Commit();
}
}
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
TermoCPFARLCR esp = especificidade as TermoCPFARLCR;
TermoCPFARLCRDa termoCPFARLCRDa = new TermoCPFARLCRDa();
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
DominialidadeDa dominialidadeDa = new DominialidadeDa();
EspecificidadeDa especificidadeDa = new EspecificidadeDa();
GerenciadorConfiguracao <ConfiguracaoCaracterizacao> caracterizacaoConfig = new GerenciadorConfiguracao <ConfiguracaoCaracterizacao>(new ConfiguracaoCaracterizacao());
string caracterizacaoTipo = caracterizacaoConfig.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes).Single(x => x.Id == (int)eCaracterizacao.Dominialidade).Texto;
List <PessoaLst> responsaveis = new List <PessoaLst>();
RequerimentoAtividade(esp, jaAssociado: false);
#region Básicas
if (esp.CedenteDominioID <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.CedenteDominioObrigatorio);
}
if (esp.CedenteARLCompensacao == null || esp.CedenteARLCompensacao.Count <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.CedenteARLCompensacaoObrigatoria);
}
else
{
if (esp.CedenteARLCompensacao.Any(x => esp.CedenteARLCompensacao.Count(y => y.Id == x.Id && y.Id > 0) > 1))
{
Validacao.Add(Mensagem.TermoCPFARLCR.CedenteARLCompensacaoDuplicada);
}
}
if (esp.CedenteResponsaveisEmpreendimento == null || esp.CedenteResponsaveisEmpreendimento.Count <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.ResponsavelEmpreendimentoObrigatorio("Cedente", "cedente"));
}
else
{
if (esp.CedenteResponsaveisEmpreendimento.Any(x => esp.CedenteResponsaveisEmpreendimento.Count(y => y.Id == x.Id && y.Id > 0) > 1))
{
Validacao.Add(Mensagem.TermoCPFARLCR.ResponsavelEmpreendimentoDuplicado("Cedente", "cedente"));
}
}
if (esp.ReceptorEmpreendimentoID <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.ReceptorEmpreendimentoObrigatorio);
}
if (esp.ReceptorDominioID <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.ReceptorDominioObrigatorio);
}
if (esp.ReceptorResponsaveisEmpreendimento == null || esp.ReceptorResponsaveisEmpreendimento.Count <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.ResponsavelEmpreendimentoObrigatorio("Receptor", "receptor"));
}
else
{
if (esp.ReceptorResponsaveisEmpreendimento.Any(x => esp.ReceptorResponsaveisEmpreendimento.Count(y => y.Id == x.Id && y.Id > 0) > 1))
{
Validacao.Add(Mensagem.TermoCPFARLCR.ResponsavelEmpreendimentoDuplicado("Receptor", "receptor"));
}
}
if (string.IsNullOrWhiteSpace(esp.NumeroAverbacao))
{
Validacao.Add(Mensagem.TermoCPFARLCR.NumeroAverbacaoObrigatorio);
}
ValidacoesGenericasBus.DataMensagem(esp.DataEmissao, "DataEmissao", "emissão");
#endregion Básicas
if (esp.Atividades.First().Id != ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.ReservaLegal))
{
Validacao.Add(Mensagem.TermoCPFARLCR.AtividadeInvalida(esp.Atividades[0].NomeAtividade));
}
if (!Validacao.EhValido)
{
return(false);
}
#region Cedente
Dominialidade dominialidadeCedente = dominialidadeDa.ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(0));
dominialidadeCedente.Dependencias = caracterizacaoBus.ObterDependencias(dominialidadeCedente.Id, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
if (dominialidadeCedente == null || dominialidadeCedente.Id <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.DominialidadeInexistente("cedente", caracterizacaoTipo));
}
else
{
string retorno = caracterizacaoValidar.DependenciasAlteradas(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), (int)eCaracterizacao.Dominialidade,
eCaracterizacaoDependenciaTipo.Caracterizacao, dominialidadeCedente.Dependencias);
if (!string.IsNullOrEmpty(retorno))
{
Validacao.Add(Mensagem.TermoCPFARLCR.CaracterizacaoDeveEstarValida("cedente", caracterizacaoTipo));
}
else
{
List <ReservaLegal> reservas = dominialidadeCedente.Dominios.SelectMany(x => x.ReservasLegais).Where(x => esp.CedenteARLCompensacao.Select(y => y.Id).Any(y => y == x.Id)).ToList();
if (reservas.Any(x => !x.Compensada))
{
Validacao.Add(Mensagem.TermoCPFARLCR.ARLCedenteTipoInvalida);
}
if (reservas.Any(x => x.SituacaoId != (int)eReservaLegalSituacao.Proposta))
{
Validacao.Add(Mensagem.TermoCPFARLCR.ARLCedenteSituacaoInvalida);
}
if (reservas.Any(x => x.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.Preservada && x.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.EmRecuperacao))
{
Validacao.Add(Mensagem.TermoCPFARLCR.ARLCedenteSituacaoVegetalInvalida);
}
if (!dominialidadeCedente.Dominios.Any(x => x.Id.GetValueOrDefault() == esp.CedenteDominioID))
{
Validacao.Add(Mensagem.TermoCPFARLCR.DominioDessassociado("cedente"));
}
esp.CedenteARLCompensacao.ForEach(reserva =>
{
ReservaLegal aux = reservas.SingleOrDefault(x => x.Id == reserva.Id);
if (aux == null || aux.Id <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.ReservaLegalDessassociadoCedente(reserva.Identificacao));
}
else
{
if (aux.MatriculaId != esp.ReceptorDominioID)
{
Validacao.Add(Mensagem.TermoCPFARLCR.ReservaLegalDessassociadoReceptorDominio(reserva.Identificacao));
}
}
});
}
}
responsaveis = especificidadeDa.ObterEmpreendimentoResponsaveis(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(0));
esp.CedenteResponsaveisEmpreendimento.ForEach(resp =>
{
PessoaLst aux = responsaveis.SingleOrDefault(x => x.Id == resp.Id);
if (aux == null || aux.Id <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.ResponsavelDessassociado("cedente", resp.NomeRazao));
}
});
#endregion Cedente
#region Receptor
Dominialidade dominialidadeReceptor = dominialidadeDa.ObterPorEmpreendimento(esp.ReceptorEmpreendimentoID);
dominialidadeReceptor.Dependencias = caracterizacaoBus.ObterDependencias(dominialidadeReceptor.Id, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
if (dominialidadeReceptor == null || dominialidadeReceptor.Id <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.DominialidadeInexistente("receptor", caracterizacaoTipo));
}
else
{
string retorno = caracterizacaoValidar.DependenciasAlteradas(esp.ReceptorEmpreendimentoID, (int)eCaracterizacao.Dominialidade,
eCaracterizacaoDependenciaTipo.Caracterizacao, dominialidadeReceptor.Dependencias);
if (!string.IsNullOrEmpty(retorno))
{
Validacao.Add(Mensagem.TermoCPFARLCR.CaracterizacaoDeveEstarValida("receptor", caracterizacaoTipo));
}
else
{
if (!dominialidadeReceptor.Dominios.Any(x => x.Id.GetValueOrDefault() == esp.ReceptorDominioID))
{
Validacao.Add(Mensagem.TermoCPFARLCR.DominioDessassociado("receptor"));
}
List <ReservaLegal> reservas = dominialidadeReceptor.Dominios.SelectMany(x => x.ReservasLegais).Where(x => esp.CedenteARLCompensacao.Select(y => y.Id).Any(y => y == x.IdentificacaoARLCedente)).ToList();
esp.CedenteARLCompensacao.ForEach(reserva =>
{
if (!reservas.Any(x => x.IdentificacaoARLCedente == reserva.Id))
{
Validacao.Add(Mensagem.TermoCPFARLCR.ReservaLegalDessassociadoReceptor(reserva.Identificacao));
}
});
}
}
responsaveis = especificidadeDa.ObterEmpreendimentoResponsaveis(esp.ReceptorEmpreendimentoID);
esp.ReceptorResponsaveisEmpreendimento.ForEach(resp =>
{
PessoaLst aux = responsaveis.SingleOrDefault(x => x.Id == resp.Id);
if (aux == null || aux.Id <= 0)
{
Validacao.Add(Mensagem.TermoCPFARLCR.ResponsavelDessassociado("receptor", resp.NomeRazao));
}
});
#endregion Receptor
List <TituloModeloLst> lista = termoCPFARLCRDa.ObterTitulosCedenteReceptor(esp.CedenteDominioID, esp.ReceptorDominioID);
lista.ForEach(titulo =>
{
if (titulo.Id != esp.Titulo.Id)
{
if (string.IsNullOrEmpty(titulo.Texto))
{
Validacao.Add(Mensagem.TermoCPFARLCR.DominioPossuiTituloCadastrado(titulo.Situacao));
}
else
{
Validacao.Add(Mensagem.TermoCPFARLCR.DominioPossuiTituloConcluido(titulo.Sigla, titulo.Texto, titulo.Situacao));
}
}
});
return(Validacao.EhValido);
}
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 bool Salvar(IEspecificidade especificidade)
{
LaudoVistoriaFlorestal esp = especificidade as LaudoVistoriaFlorestal;
RequerimentoAtividade(esp, apenasObrigatoriedade: true);
Destinatario(especificidade.ProtocoloReq.Id, esp.Destinatario, "Laudo_Destinatario");
ValidacoesGenericasBus.DataMensagem(esp.DataVistoria, "Laudo_DataVistoria_DataTexto", "vistoria");
if (String.IsNullOrWhiteSpace(esp.Objetivo))
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ObjetivoObrigatorio);
}
if (esp.Caracterizacao <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.CaracterizacaoObrigatoria);
}
else
{
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
int caracterizacao = caracterizacaoBus.Existe(esp.Titulo.EmpreendimentoId.GetValueOrDefault(), (eCaracterizacao)esp.Caracterizacao);
if (caracterizacao <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.CaracterizacaoCadastrada);
}
else
{
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
List <Dependencia> dependencias = caracterizacaoBus.ObterDependencias(caracterizacao,
(eCaracterizacao)esp.Caracterizacao,
eCaracterizacaoDependenciaTipo.Caracterizacao);
string retorno = caracterizacaoValidar.DependenciasAlteradas(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(),
esp.Caracterizacao,
eCaracterizacaoDependenciaTipo.Caracterizacao,
dependencias);
if (!string.IsNullOrEmpty(retorno))
{
List <CaracterizacaoLst> caracterizacoes = _caracterizacaoConfig.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes);
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.CaracterizacaoInvalida(caracterizacoes.SingleOrDefault(x => x.Id == esp.Caracterizacao).Texto));
}
}
}
if (String.IsNullOrWhiteSpace(esp.Consideracao))
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ConsideracoesObrigatorio);
}
if (String.IsNullOrWhiteSpace(esp.ParecerDescricao))
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ParecerTecnicoDescricaoObrigatorio);
}
if (esp.Conclusao <= 0)
{
Validacao.Add(Mensagem.LaudoVistoriaFlorestalMsg.ConclusaoObrigatoria);
}
return(Validacao.EhValido);
}
public bool Salvar(UnidadeProducao caracterizacao, int projetoDigitalId)
{
try
{
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
EmpreendimentoCaracterizacao empreendimento = caracterizacaoBus.ObterEmpreendimentoSimplificado(caracterizacao.Empreendimento.Id);
UnidadeProducaoInternoBus unidadeConsolidacaoInternoBus = new UnidadeProducaoInternoBus();
UnidadeProducao caracterizacaoInterno = unidadeConsolidacaoInternoBus.ObterPorEmpreendimento(empreendimento.InternoID, true);
caracterizacao.InternoID = caracterizacaoInterno.Id;
caracterizacao.InternoTID = caracterizacaoInterno.Tid;
if (!_validar.Salvar(caracterizacao, projetoDigitalId))
{
return(Validacao.EhValido);
}
#region Configurar Salvar
UnidadeProducao caracterizacaoBanco = ObterPorEmpreendimento(caracterizacao.Empreendimento.Id);
if (caracterizacaoInterno.Id > 0)
{
caracterizacao.PossuiCodigoPropriedade = caracterizacaoInterno.PossuiCodigoPropriedade;
caracterizacao.CodigoPropriedade = caracterizacaoInterno.CodigoPropriedade;
}
else
{
if (!caracterizacao.PossuiCodigoPropriedade)
{
if (caracterizacao.Id < 1)
{
caracterizacao.CodigoPropriedade = _da.ObterSequenciaCodigoPropriedade();
}
else
{
caracterizacao.CodigoPropriedade = caracterizacaoBanco.CodigoPropriedade;
}
}
}
RequestJson requestJson = new RequestJson();
ResponseJsonData <dynamic> resposta = new ResponseJsonData <dynamic>();
int ultimoCodigoUP = _da.ObterUltimoCodigoUP(caracterizacao.Empreendimento.Id);
foreach (long item in caracterizacao.UnidadesProducao.Where(x => x.PossuiCodigoUP).Select(x => x.CodigoUP))
{
int aux = Convert.ToInt32(item.ToString().Substring(14));
if (aux > ultimoCodigoUP)
{
ultimoCodigoUP = aux;
}
}
foreach (UnidadeProducaoItem item in caracterizacao.UnidadesProducao)
{
int codigoIbge = 0;
resposta = requestJson.Executar <dynamic>(_configCoordenada.Obter <String>(ConfiguracaoCoordenada.KeyUrlObterMunicipioCoordenada) + "?easting=" + item.Coordenada.EastingUtm + "&northing=" + item.Coordenada.NorthingUtm);
if (resposta.Erros != null && resposta.Erros.Count > 0)
{
Validacao.Erros.AddRange(resposta.Erros);
return(Validacao.EhValido);
}
var objJson = resposta.Data;
if (objJson["EstaNoEstado"] && (objJson["Municipio"] == null || Convert.ToInt32(objJson["Municipio"]["IBGE"] ?? 0) == 0))
{
Validacao.Add(Mensagem.Mapas.MunicipioSemRetorno);
}
if (!Validacao.EhValido)
{
return(Validacao.EhValido);
}
if (objJson["Municipio"] != null)
{
codigoIbge = Convert.ToInt32(objJson["Municipio"]["IBGE"] ?? 0);
}
ListaValoresDa listaValoresDa = new ListaValoresDa();
item.Municipio = listaValoresDa.ObterMunicipio(codigoIbge);
if (!item.PossuiCodigoUP)
{
item.AnoAbertura = DateTime.Today.Year.ToString().Substring(2);
if (item.Id < 1)
{
ultimoCodigoUP++;
item.CodigoUP = Convert.ToInt64(
item.Municipio.Ibge.ToString() +
caracterizacao.CodigoPropriedade.ToString("D4") +
item.AnoAbertura +
ultimoCodigoUP.ToString("D2"));
}
else
{
item.CodigoUP = caracterizacaoBanco.UnidadesProducao.Single(x => x.Id == item.Id).CodigoUP;
}
}
else
{
item.AnoAbertura = item.CodigoUP.ToString().Substring(11, 2);
}
foreach (var aux in item.ResponsaveisTecnicos)
{
aux.CFONumero = aux.CFONumero.Split('-').GetValue(0).ToString();
}
}
#endregion
if (caracterizacao.UnidadesProducao.Any(x => caracterizacao.UnidadesProducao.Count(y => y.CodigoUP == x.CodigoUP) > 1))
{
Validacao.Add(Mensagem.UnidadeProducao.UnidadeProducaoItemIncorreto);
return(false);
}
foreach (var item in caracterizacao.UnidadesProducao)
{
if (item.CodigoUP.ToString().Substring(7, 4) != caracterizacao.CodigoPropriedade.ToString("D4"))
{
Validacao.Add(Mensagem.UnidadeProducao.CodigoUPNaoContemCodPropriedade(item.CodigoUP));
return(false);
}
}
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(UsuarioCredenciado))
{
bancoDeDados.IniciarTransacao();
_da.Salvar(caracterizacao, bancoDeDados);
Validacao.Add(Mensagem.UnidadeProducao.SalvoSucesso);
bancoDeDados.Commit();
}
}
catch (Exception e)
{
Validacao.AddErro(e);
}
return(Validacao.EhValido);
}
public bool Excluir(int empreendimento)
{
if (!EmPosse(empreendimento))
{
Validacao.Add(Mensagem.Empreendimento.Posse);
return(Validacao.EhValido);
}
List <String> requerimentosAssociados = _da.VerificarEmpreendimentoRequerimento(empreendimento);
if (requerimentosAssociados.Count > 0)
{
foreach (String numero in requerimentosAssociados)
{
Validacao.Add(Mensagem.Empreendimento.EmpreedimentoAssociado("requerimento", numero));
}
}
CaracterizacaoBus caractBus = new CaracterizacaoBus();
IEnumerable <Dependencia> lstDepDominialidade = caractBus.ObterDependenciasAtual(empreendimento, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao)
.Where(x => x.DependenciaId > 0);
if (lstDepDominialidade != null && lstDepDominialidade.Count() > 0)
{
List <DependenciaLst> dependentes = caractBus.CaracterizacaoConfig.Obter <List <DependenciaLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoesDependencias);
Validacao.Add(Mensagem.Empreendimento.AssociadoDependencias(lstDepDominialidade.Select(x => dependentes.First(lstDep => lstDep.TipoId == x.DependenciaTipo).TipoTexto).ToList()));
}
List <Caracterizacao> lstCaractCadastradas = caractBus.ObterCaracterizacoesEmpreendimento(empreendimento) ?? new List <Caracterizacao>();
lstCaractCadastradas = lstCaractCadastradas.Where(x => x.Id > 0).ToList();
List <CaracterizacaoLst> caracterizacoes = caractBus.CaracterizacaoConfig.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes);
if (lstCaractCadastradas.Count > 0)
{
Validacao.Add(Mensagem.Empreendimento.AssociadoCaracterizacoes(lstCaractCadastradas.Select(x => caracterizacoes.Single(c => c.Id == (int)x.Tipo).Texto).ToList()));
}
List <String> listString = null;
//Associado ao Documento
listString = _da.VerificarEmpreendimentoDocumento(empreendimento);
if (listString != null && listString.Count > 0)
{
listString.ForEach(x => Validacao.Add(Msg.AssociadoDocumento(x)));
}
//Associado ao Processo
listString = _da.VerificarEmpreendimentoProcesso(empreendimento);
if (listString != null && listString.Count > 0)
{
listString.ForEach(x => Validacao.Add(Msg.AssociadoProcesso(x)));
}
//Associado ao Título
listString = _da.VerificarEmpreendimentoTitulo(empreendimento);
if (listString != null && listString.Count > 0)
{
listString.ForEach(x => Validacao.Add(Msg.AssociadoTitulo(x)));
}
//Associado a Fiscalização
listString = _da.VerificarEmpreendimentoFiscalizacoes(empreendimento);
if (listString != null && listString.Count > 0)
{
listString.ForEach(x => Validacao.Add(Msg.AssociadoFiscalizacao(x)));
}
return(Validacao.EhValido);
}
