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 ActionResult Criar(int empreendimento, int tipo, bool isCadastrarCaracterizacao)
{
if (!_caracterizacaoValidar.Dependencias(empreendimento, tipo))
{
return(RedirectToAction("", "Caracterizacao", new { id = empreendimento, Msg = Validacao.QueryParam() }));
}
DescricaoLicenciamentoAtividadeVM vm = new DescricaoLicenciamentoAtividadeVM();
DescricaoLicenciamentoAtividade dscLicAtividade = _bus.ObterPorEmpreendimento(empreendimento, (eCaracterizacao)tipo);
dscLicAtividade = _bus.ObterDadosGeo(empreendimento, (eCaracterizacao)tipo, dscLicAtividade);
if (dscLicAtividade.Id == 0)
{
dscLicAtividade.Tipo = tipo;
}
vm.CaracterizacaoTipoTexto = _caracterizacaoBus.ObterCaracterizacoesEmpreendimento(empreendimento).SingleOrDefault(x => (int)x.Tipo == tipo).Nome;
dscLicAtividade.EmpreendimentoId = empreendimento;
vm.DscLicAtividade = dscLicAtividade;
vm.IsCadastrarCaracterizacao = isCadastrarCaracterizacao;
vm.ResponsaveisEmpreendimento = ViewModelHelper.CriarSelectList(_bus.ObterResponsaveis(empreendimento));
vm.FontesAbastecimentoAguaTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvFontesAbastecimentoAguaTipo);
vm.PontosLancamentoEfluenteTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvPontosLancamentoEfluenteTipo);
vm.OutorgaAguaTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvOutorgaAguaTipo);
vm.FontesGeracaoTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvFontesGeracaoTipo);
vm.UnidadeTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvUnidadeTipo);
vm.CombustivelTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvCombustivelTipo);
vm.VegetacaoAreaUtil = _listaBus.DscLicAtvVegetacaoAreaUtil;
vm.Acondicionamento = _listaBus.DscLicAtvAcondicionamento;
vm.Estocagem = _listaBus.DscLicAtvEstocagem;
vm.Tratamento = _listaBus.DscLicAtvTratamento;
vm.DestinoFinal = _listaBus.DscLicAtvDestinoFinal;
if (vm.DscLicAtividade.Id > 0)
{
vm.DscLicAtividade.Dependencias = _caracterizacaoBus.ObterDependencias(vm.DscLicAtividade.Id, vm.DscLicAtividade.GetTipo, eCaracterizacaoDependenciaTipo.DescricaoLicenciamentoAtividade);
vm.TextoMerge = _caracterizacaoValidar.DependenciasAlteradas(
vm.DscLicAtividade.EmpreendimentoId,
vm.DscLicAtividade.Tipo,
eCaracterizacaoDependenciaTipo.DescricaoLicenciamentoAtividade,
vm.DscLicAtividade.Dependencias);
vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
}
if (vm.ResponsaveisEmpreendimento != null && vm.ResponsaveisEmpreendimento.Count == 2)
{
vm.DscLicAtividade.RespAtividade = Int32.Parse(vm.ResponsaveisEmpreendimento.First(x => int.Parse(x.Value) > 0).Value);
}
vm.UrlAvancar = CaracterizacaoVM.GerarUrl(empreendimento, isCadastrarCaracterizacao, (eCaracterizacao)tipo);
return(View("Criar", vm));
}
public ExploracaoFlorestal ObterPorId(int id, bool simplificado = false, BancoDeDados banco = null)
{
ExploracaoFlorestal caracterizacao = null;
try
{
caracterizacao = _da.Obter(id, banco, simplificado);
caracterizacao.Dependencias = _busCaracterizacao.ObterDependencias(caracterizacao.Id, eCaracterizacao.ExploracaoFlorestal, eCaracterizacaoDependenciaTipo.Caracterizacao);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
public RegularizacaoFundiaria ObterPorEmpreendimento(int empreendimento, bool simplificado = false, BancoDeDados banco = null)
{
RegularizacaoFundiaria caracterizacao = null;
try
{
caracterizacao = _da.ObterPorEmpreendimento(empreendimento, simplificado, banco);
caracterizacao.Dependencias = _busCaracterizacao.ObterDependencias(caracterizacao.Id, eCaracterizacao.RegularizacaoFundiaria, eCaracterizacaoDependenciaTipo.Caracterizacao, banco);
int zona = (int)_busCaracterizacao.ObterEmpreendimentoSimplificado(empreendimento).ZonaLocalizacao;
caracterizacao.Posses.ForEach(x =>
{
x.Zona = zona;
});
caracterizacao.Posses = caracterizacao.Posses.OrderBy(x => x.Identificacao).ToList();
caracterizacao.Matriculas = _busDominialidade.ObterPorEmpreendimento(empreendimento).Dominios.Where(x => x.Tipo == eDominioTipo.Matricula).ToList();
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
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);
}
internal bool AssociarDependencias(ProjetoDigital projetoDigital)
{
Dependencia caracterizacao = projetoDigital.Dependencias.FirstOrDefault(x => x.DependenciaTipo == (int)eCaracterizacaoDependenciaTipo.Caracterizacao) ?? new Dependencia();
List <Dependencia> dependencias = _busCaracterizacao.ObterDependencias(
caracterizacao.DependenciaId,
(eCaracterizacao)caracterizacao.DependenciaCaracterizacao,
eCaracterizacaoDependenciaTipo.Caracterizacao);
string retorno = _validarCaracterizacao.DependenciasAlteradas(
projetoDigital.EmpreendimentoId.GetValueOrDefault(),
caracterizacao.DependenciaCaracterizacao,
eCaracterizacaoDependenciaTipo.Caracterizacao,
dependencias);
if (!string.IsNullOrEmpty(retorno))
{
Validacao.Add(Mensagem.ProjetoDigital.AssociadaProjetoDigitalCaracterizacaoInvalida);
}
else
{
if ((eCaracterizacao)caracterizacao.DependenciaCaracterizacao == eCaracterizacao.UnidadeProducao)
{
ICaracterizacaoBus caracterizacaoBus = CaracterizacaoBusFactory.Criar(eCaracterizacao.UnidadeProducao);
caracterizacaoBus.ValidarAssociar(caracterizacao.DependenciaId, projetoDigital.Id);
}
}
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 CadastroAmbientalRural ObterPorEmpreendimento(int empreendimento, bool finalizado, bool simplificado = false, BancoDeDados banco = null)
{
CadastroAmbientalRural caracterizacao = null;
try
{
caracterizacao = _da.ObterPorEmpreendimento(empreendimento, simplificado, finalizado);
caracterizacao.SituacaoProcessamento = ObterSituacaoProcessamento(caracterizacao.EmpreendimentoId);
caracterizacao.Dependencias = _caracterizacaoBus.ObterDependencias(caracterizacao.Id, eCaracterizacao.CadastroAmbientalRural, eCaracterizacaoDependenciaTipo.Caracterizacao);
caracterizacao.PercentMaximaRecuperacaoAPP = CalcularPorcentagemMaximaModuloFiscal(caracterizacao.ATPQuantidadeModuloFiscal);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
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 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);
}
public ProjetoGeografico ObterProjeto(int projetoGeoID, int projetoDigitalID = 0, bool simplificado = false)
{
ProjetoGeografico projeto = null;
try
{
projeto = _da.Obter(projetoGeoID, null, simplificado, (!_da.ValidarProjetoGeograficoTemporario(projetoGeoID)));
if (projeto.Id > 0 && !simplificado)
{
projeto.Dependencias = _caracterizacaoBus.ObterDependencias(projetoGeoID, (eCaracterizacao)projeto.CaracterizacaoId, eCaracterizacaoDependenciaTipo.ProjetoGeografico);
ObterOrtofotos(projeto);
#region Sobreposicoes
if (projeto.Sobreposicoes.Itens != null && projeto.Sobreposicoes.Itens.Count > 0)
{
foreach (var item in SobreposicaoTipo)
{
if (projeto.Sobreposicoes.Itens.Exists(x => x.Tipo == item.Id))
{
projeto.Sobreposicoes.Itens.First(x => x.Tipo == item.Id).TipoTexto = item.Texto;
}
else
{
projeto.Sobreposicoes.Itens.Add(new Sobreposicao()
{
Tipo = item.Id,
TipoTexto = item.Texto,
Base = (int)((item.Id == (int)eSobreposicaoTipo.OutrosEmpreendimento) ? eSobreposicaoBase.IDAF : eSobreposicaoBase.GeoBase),
Identificacao = " - "
});
}
}
}
#endregion
}
return(projeto);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(projeto);
}
public Barragem ObterPorEmpreendimento(int empreendimento, bool simplificado = false, BancoDeDados banco = null)
{
Barragem caracterizacao = null;
try
{
caracterizacao = _da.ObterPorEmpreendimento(empreendimento, simplificado: simplificado);
caracterizacao.Dependencias = _busCaracterizacao.ObterDependencias(caracterizacao.Id, eCaracterizacao.Barragem, eCaracterizacaoDependenciaTipo.Caracterizacao);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
public SilviculturaATV ObterPorEmpreendimento(int EmpreendimentoId, bool simplificado = false, BancoDeDados banco = null)
{
SilviculturaATV caracterizacao = null;
try
{
caracterizacao = _da.ObterPorEmpreendimento(EmpreendimentoId, simplificado: simplificado);
caracterizacao.Dependencias = _busCaracterizacao.ObterDependencias(caracterizacao.Id, eCaracterizacao.SilviculturaATV, eCaracterizacaoDependenciaTipo.Caracterizacao);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
public ProducaoCarvaoVegetal ObterPorEmpreendimento(int EmpreendimentoId, bool simplificado = false, BancoDeDados banco = null)
{
ProducaoCarvaoVegetal caracterizacao = null;
try
{
caracterizacao = _da.ObterPorEmpreendimento(EmpreendimentoId, simplificado: simplificado);
caracterizacao.Dependencias = _busCaracterizacao.ObterDependencias(caracterizacao.Id, eCaracterizacao.ProducaoCarvaoVegetal, eCaracterizacaoDependenciaTipo.Caracterizacao);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
public Dominialidade ObterPorEmpreendimento(int empreendimento, int projetoDigitalId = 0, bool simplificado = false, BancoDeDados banco = null, bool isVisualizar = false)
{
Dominialidade caracterizacao = null;
try
{
List <Caracterizacao> caracterizacoesAssociadas = _busCaracterizacao.ObterCaracterizacoesAssociadasProjetoDigital(projetoDigitalId).Where(x => x.Tipo == eCaracterizacao.Dominialidade).ToList();
if (caracterizacoesAssociadas != null && caracterizacoesAssociadas.Count > 0)
{
caracterizacao = ObterHistorico(caracterizacoesAssociadas.FirstOrDefault().Id, caracterizacoesAssociadas.FirstOrDefault().Tid);
}
else
{
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 = r.Coordenada;
reserva.Coordenada.Datum.Id = 1;
reserva.Coordenada.Tipo.Id = 3;
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;
}
}
}
}
if (!isVisualizar && !caracterizacao.Areas.Exists(x => x.Tipo == (int)eDominialidadeArea.ARL_PRESERVADA))
{
ObterDominialidadeARL(caracterizacao);
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(caracterizacao);
}
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(CARSolicitacao entidade)
{
if (!_protocoloDa.EmPosse(entidade.Protocolo.Id.GetValueOrDefault()))
{
Validacao.Add(Mensagem.CARSolicitacao.ProtocoloPosse);
return(false);
}
if (entidade.SituacaoId <= 0)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoSituacaoObrigatoria);
}
if (entidade.Protocolo == null || entidade.Protocolo.Id.GetValueOrDefault(0) <= 0)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoProtocoloObrigatorio);
}
if (entidade.Requerimento.Id <= 0)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoRequerimentoObrigatorio);
}
_requerimentoValidar.Existe(entidade.Requerimento.Id);
if (entidade.SituacaoId == (int)eCARSolicitacaoSituacao.EmCadastro)
{
if (entidade.Protocolo.Id.GetValueOrDefault() != entidade.ProtocoloSelecionado.Id.GetValueOrDefault())
{
if (!_da.ExisteProtocoloAssociado(entidade.Protocolo.Id.GetValueOrDefault(), entidade.ProtocoloSelecionado.Id.GetValueOrDefault()))
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoRequerimentoDesassociadoProtocolo(entidade.Requerimento.Numero.ToString()));
}
}
String numeroProtocoloPai = _da.ObterNumeroProtocoloPai(entidade.Protocolo.Id.GetValueOrDefault(0));
if (!String.IsNullOrWhiteSpace(numeroProtocoloPai))
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoProtocoloApensadoEmOutroProcesso(numeroProtocoloPai));
}
}
#region Atividade
if (entidade.Atividade.Id <= 0)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoAtividadeObrigatoria);
}
else
{
if (entidade.Atividade.Id != ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.CadastroAmbientalRural))
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoAtividadeInvalida);
}
}
#endregion Atividade
#region Validar Dados do Titulo
String tituloSituacao = _da.ObterSituacaoTituloCARExistente(entidade.Empreendimento.Id);
if (!String.IsNullOrWhiteSpace(tituloSituacao))
{
Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoPossuiTitulo(tituloSituacao));
return(false);
}
#endregion Validar Dados do Titulo
#region Empreendimento
if (!entidade.Empreendimento.Codigo.HasValue)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoEmpreendimentoCodigoObrigatorio);
}
if (entidade.Empreendimento.Id <= 0)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoEmpreendimentoObrigatorio);
}
else
{
String situacao = _da.EmpreendimentoPossuiSolicitacao(entidade.Id, entidade.Empreendimento.Id);
if (!String.IsNullOrEmpty(situacao))
{
Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoJaPossuiSolicitacao(situacao));
return(Validacao.EhValido);
}
situacao = _carSolicitacaoCredenciadoBus.EmpreendimentoPossuiSolicitacao(entidade.Empreendimento.Id);
if (!String.IsNullOrEmpty(situacao))
{
Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoJaPossuiSolicitacao(situacao));
return(Validacao.EhValido);
}
entidade.Empreendimento.CNPJ = _da.ObterCNPJEmpreendimento(entidade.Empreendimento.Id);
if (!String.IsNullOrWhiteSpace(entidade.Empreendimento.CNPJ))
{
situacao = _carSolicitacaoCredenciadoBus.EmpreendimentoPossuiSolicitacao(entidade.Empreendimento.CNPJ);
if (!String.IsNullOrEmpty(situacao))
{
Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoJaPossuiSolicitacao(situacao));
return(Validacao.EhValido);
}
}
}
#endregion Empreendimento
#region Validar Dados da Caracterizacao
if (_da.EmpreendimentoProjetoGeograficoDominialidadeNaoFinalizado(entidade.Empreendimento.Id))
{
Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoProjetoGeograficoDominialidadeNaoFinalizado);
}
else
{
int idCaracterizacao = 0;
List <Dependencia> dependencias;
idCaracterizacao = _caracterizacaoBus.Existe(entidade.Empreendimento.Id, eCaracterizacao.Dominialidade);
if (idCaracterizacao > 0)
{
dependencias = _caracterizacaoBus.ObterDependencias(idCaracterizacao, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
if (_caracterizacaoValidar.DependenciasAlteradas(entidade.Empreendimento.Id, (int)eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao, dependencias) != String.Empty)
{
Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoDominialidadeInvalida);
}
}
else
{
Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoDominialidadeInexistente);
}
}
#endregion Validar Dados da Caracterizacao
if (entidade.Declarante.Id <= 0)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoDeclaranteObrigatorio);
}
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
#region Variáveis
OutrosLegitimacaoTerraDevolutaDa _da = new OutrosLegitimacaoTerraDevolutaDa();
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
List <Dependencia> dependencias = new List <Dependencia>();
OutrosLegitimacaoTerraDevoluta esp = especificidade as OutrosLegitimacaoTerraDevoluta;
List <Caracterizacao> caracterizacoes = caracterizacaoBus.ObterCaracterizacoesEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
int idCaracterizacao;
string titulo = string.Empty;
#endregion
#region Requerimento
//O requerimento <nº> não está mais associado ao processo <nº>.
//A atividade <nome> não está mais associada ao processo.
//A atividade <nome> deve estar na situação ‘em andamento’.
//Este modelo de título não foi solicitado para a atividade <nome>’.
RequerimentoAtividade(esp, apenasObrigatoriedade: true);
#endregion
#region Atividade
//O modelo de título <nome do modelo> não pode ser utilizado para atividade <nome da atividade selecionada na especificidade do título>.
if (!ConfiguracaoAtividade.ObterId(new[] {
(int)eAtividadeCodigo.RegularizacaoFundiariaRural,
(int)eAtividadeCodigo.RegularizacaoFundiariaUrbana,
(int)eAtividadeCodigo.RegularizacaoFundiariaRuralOriundaDeProcessoDiscriminatorio,
(int)eAtividadeCodigo.RegularizacaoFundiariaUrbanaOriundaDeProcessoDiscriminatorio
}).Any(x => x == esp.Atividades[0].Id))
{
Validacao.Add(Mensagem.OutrosLegitimacaoTerraDevolutaMsg.AtividadeInvalida(esp.Atividades[0].NomeAtividade));
}
#endregion
#region Destinatários
if (esp.Destinatarios.Count == 0)
{
Validacao.Add(Mensagem.Especificidade.DestinatarioObrigatorio("Outros_Destinatarios"));
}
else
{
esp.Destinatarios.ForEach(x =>
{
Destinatario(esp.ProtocoloReq.Id, x.Id, "Outros_Destinatarios");
});
}
#endregion
#region Caracterização
//A caracterização de <nome da caracterização> deve estar cadastrada.
//Para cadastrar este modelo de título é necessário ter os dados da caracterização <nome da caracterização dependente> válidos.
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.OutrosLegitimacaoTerraDevolutaMsg.CaracterizacaoValida(caracterizacoes.Single(x => x.Tipo == eCaracterizacao.RegularizacaoFundiaria).Nome));
}
}
else
{
Validacao.Add(Mensagem.OutrosLegitimacaoTerraDevolutaMsg.CaracterizacaoCadastrada);
}
#endregion
#region Posse
if (esp.Dominio == 0)
{
Validacao.Add(Mensagem.OutrosLegitimacaoTerraDevolutaMsg.DominioObrigatorio);
}
else
{
if (!_da.IsDominioCadastrado(esp.Dominio))
{
Validacao.Add(Mensagem.OutrosLegitimacaoTerraDevolutaMsg.DominioInexistente);
}
TituloEsp tituloAux = _da.IsDominioAssociado(esp.Dominio, esp.Titulo.Id);
switch ((eTituloSituacao)tituloAux.SituacaoId)
{
case eTituloSituacao.Cadastrado:
case eTituloSituacao.Emitido:
case eTituloSituacao.Assinado:
Validacao.Add(Mensagem.OutrosLegitimacaoTerraDevolutaMsg.PosseAssociadaSituacao(tituloAux.SituacaoTexto));
break;
case eTituloSituacao.Concluido:
case eTituloSituacao.Prorrogado:
Validacao.Add(Mensagem.OutrosLegitimacaoTerraDevolutaMsg.PosseAssociadaNumero(tituloAux.Numero.Texto));
break;
}
}
#endregion
if (string.IsNullOrWhiteSpace(esp.ValorTerreno))
{
Validacao.Add(Mensagem.OutrosLegitimacaoTerraDevolutaMsg.ValorTerrenoObrigatorio);
}
if (!esp.IsInalienabilidade.HasValue)
{
Validacao.Add(Mensagem.OutrosLegitimacaoTerraDevolutaMsg.IsInalienabilidadeObrigatorio);
}
if (esp.MunicipioGlebaId <= 0)
{
Validacao.Add(Mensagem.OutrosLegitimacaoTerraDevolutaMsg.MunicipioGlebaObrigatorio);
}
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 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 bool Salvar(IEspecificidade especificidade)
{
TermoCPFARLDa _da = new TermoCPFARLDa();
EspecificidadeDa _daEspecificidade = new EspecificidadeDa();
DominialidadeDa _daDominialidade = new DominialidadeDa();
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
CaracterizacaoValidar caracterizacaoValidar = new CaracterizacaoValidar();
List <Dependencia> dependencias = new List <Dependencia>();
TermoCPFARL esp = especificidade as TermoCPFARL;
List <Caracterizacao> caracterizacoes = caracterizacaoBus.ObterCaracterizacoesEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
List <PessoaLst> destinatarios = _daEspecificidade.ObterInteressados(esp.ProtocoloReq.Id);
List <ReservaLegal> reservas;
int idCaracterizacao;
int tipo;
RequerimentoAtividade(esp);
if (esp.Atividades[0].Id != ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.ReservaLegal))
{
Validacao.Add(Mensagem.TermoCPFARLMsg.AtividadeInvalida(esp.Atividades[0].NomeAtividade));
}
if (esp.Destinatarios.Count == 0)
{
Validacao.Add(Mensagem.Especificidade.DestinatarioObrigatorio("Termo_Destinatario"));
}
else
{
esp.Destinatarios.ForEach(x =>
{
if (destinatarios.SingleOrDefault(y => y.Id == x.Id) == null)
{
Validacao.Add(Mensagem.Especificidade.DestinatarioDesassociado("Termo_Destinatario", x.Nome));
}
else
{
tipo = _daEspecificidade.ObterDadosPessoa(x.Id).Tipo;
if (tipo == 3 || tipo == 4)
{
Validacao.Add(Mensagem.TermoCPFARLMsg.DestinatarioNaoPermitido);
}
}
});
}
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.TermoCPFARLMsg.CaracterizacaoDeveEstarValida(caracterizacoes.Single(x => x.Tipo == eCaracterizacao.Dominialidade).Nome));
}
else
{
reservas = new List <ReservaLegal>();
Dominialidade dominialidade = _daDominialidade.ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(0));
dominialidade.Dominios.ForEach(x => { x.ReservasLegais.ForEach(reserva => { reservas.Add(reserva); }); });
if (reservas == null || reservas.Count == 0)
{
Validacao.Add(Mensagem.TermoCPFARLMsg.ArlInexistente);
}
else
{
if (reservas.Exists(x => x.SituacaoVegetalId == (int)eReservaLegalSituacaoVegetal.NaoCaracterizada || x.SituacaoVegetalId == (int)eReservaLegalSituacaoVegetal.EmUso))
{
Validacao.Add(Mensagem.TermoCPFARLMsg.ARLSituacaoVegetalInvalida);
}
if (reservas.Exists(x => x.SituacaoId != (int)eReservaLegalSituacao.Proposta))
{
Validacao.Add(Mensagem.TermoCPFARLMsg.DominioSituacaoInvalida);
}
if (reservas.Exists(x => x.LocalizacaoId == (int)eReservaLegalLocalizacao.CompensacaoMatriculaCedente ||
x.LocalizacaoId == (int)eReservaLegalLocalizacao.CompensacaoMatriculaReceptora ||
x.LocalizacaoId == (int)eReservaLegalLocalizacao.CompensacaoEmpreendimentoCedente ||
x.LocalizacaoId == (int)eReservaLegalLocalizacao.CompensacaoEmpreendimentoReceptora))
{
Validacao.Add(Mensagem.TermoCPFARLMsg.LocalizacaoInvalida);
}
}
}
}
else
{
Validacao.Add(Mensagem.TermoCPFARLMsg.DominialidadeInexistente);
}
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
#region Validacoes Genericas
LaudoAuditoriaFomentoFlorestal esp = especificidade as LaudoAuditoriaFomentoFlorestal;
RequerimentoAtividade(esp, false, true);
Destinatario(especificidade.ProtocoloReq.Id, esp.Destinatario, "Laudo_Destinatario");
ValidacoesGenericasBus.DataMensagem(esp.DataVistoria, "Laudo_DataVistoria_DataTexto", "vistoria");
#endregion
#region Objetivo
if (String.IsNullOrWhiteSpace(esp.Objetivo))
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.ObjetivoObrigatorio);
}
#endregion
#region PlantioAPP
if (!esp.PlantioAPP.HasValue)
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioAPPObrigatorio);
}
else
{
if (esp.PlantioAPP.Value == 1)
{
if (!String.IsNullOrWhiteSpace(esp.PlantioAPPArea))
{
Decimal aux = 0;
if (!Decimal.TryParse(esp.PlantioAPPArea, out aux))
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioAPPAreaInvalida);
}
if (aux <= 0)
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioAPPAreaMaiorZero);
}
}
else
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioAPPAreaObrigatoria);
}
}
}
#endregion
#region PlantioMudasEspeciesFlorestNativas
if (!esp.PlantioMudasEspeciesFlorestNativas.HasValue)
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioMudasEspeciesFlorestNativasObrigatorio);
}
else
{
if (esp.PlantioMudasEspeciesFlorestNativas.Value == 1)
{
if (!String.IsNullOrWhiteSpace(esp.PlantioMudasEspeciesFlorestNativasArea))
{
Decimal aux = 0;
if (!Decimal.TryParse(esp.PlantioMudasEspeciesFlorestNativasArea, out aux))
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioMudasEspeciesFlorestNativasAreaInvalida);
}
if (aux <= 0)
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioMudasEspeciesFlorestNativasAreaMaiorZero);
}
}
else
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioMudasEspeciesFlorestNativasAreaObrigatoria);
}
if (!String.IsNullOrWhiteSpace(esp.PlantioMudasEspeciesFlorestNativasQtd))
{
Decimal aux = 0;
if (!Decimal.TryParse(esp.PlantioMudasEspeciesFlorestNativasQtd, out aux))
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioMudasEspeciesFlorestNativasQtdInvalida);
}
if (aux <= 0)
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioMudasEspeciesFlorestNativasQtdMaiorZero);
}
}
else
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PlantioMudasEspeciesFlorestNativasQtdObrigatoria);
}
}
}
#endregion
#region PreparoSolo
if (!esp.PreparoSolo.HasValue)
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PreparoSoloObrigatorio);
}
else
{
if (esp.PreparoSolo.Value == 1)
{
if (!String.IsNullOrWhiteSpace(esp.PreparoSoloArea))
{
Decimal aux = 0;
if (!Decimal.TryParse(esp.PreparoSoloArea, out aux))
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PreparoSoloAreaInvalida);
}
if (aux <= 0)
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PreparoSoloAreaMaiorZero);
}
}
else
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.PreparoSoloAreaObrigatoria);
}
}
}
#endregion
#region Resultado
if (esp.ResultadoTipo <= 0)
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.ResultadoObrigatorio);
}
else
{
if (esp.ResultadoTipo == (int)eEspecificidadeResultado.NaoConforme)
{
if (String.IsNullOrWhiteSpace(esp.ResultadoQuais))
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.ResultadoQuaisObrigatorio);
}
}
}
#endregion
#region Caracterizacao
CaracterizacaoBus caracterizacaoBus = new CaracterizacaoBus();
int caracterizacao = caracterizacaoBus.Existe(esp.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.SilviculturaATV);
if (caracterizacao <= 0)
{
Validacao.Add(Mensagem.LaudoAuditoriaFomentoFlorestal.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.LaudoAuditoriaFomentoFlorestal.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.LaudoAuditoriaFomentoFlorestal.AtividadeInvalida(atividades.SingleOrDefault(x => x.Id == atividade.Id).Texto));
}
}
#endregion
return(Validacao.EhValido);
}
public bool Salvar(IEspecificidade especificidade)
{
CadastroAmbientalRuralTitulo esp = especificidade as CadastroAmbientalRuralTitulo;
List <Dependencia> dependencias = new List <Dependencia>();
List <Caracterizacao> caracterizacoes = caracterizacaoBus.ObterCaracterizacoesEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
int idCaracterizacao;
RequerimentoAtividade(esp);
if (Destinatario(especificidade.ProtocoloReq.Id, esp.Destinatario, "CadastroAmbientalRuralTitulo_Destinatario"))
{
if (!ValidarDestinatarioIsRepresentanteEmpreendimento(esp.ProtocoloReq.Id, esp.Destinatario))
{
Validacao.Add(Mensagem.CadastroAmbientalRuralTitulo.DestinatarioNaoEstaAssociadoEmpreendimento);
}
}
if (esp.Atividades[0].Id != ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.CadastroAmbientalRural))
{
Validacao.Add(Mensagem.CadastroAmbientalRuralTitulo.AtividadeInvalida);
}
else
{
String tituloNumero = _da.ObterNumeroTituloCARExistente(esp.Titulo.EmpreendimentoId.GetValueOrDefault(0));
if (!String.IsNullOrWhiteSpace(tituloNumero))
{
Validacao.Add(Mensagem.CadastroAmbientalRuralTitulo.AtividadeJaAssociadaOutroTitulo(tituloNumero));
}
}
#region Caracterizacao
idCaracterizacao = caracterizacaoBus.Existe(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.CadastroAmbientalRural);
if (idCaracterizacao > 0)
{
if (especificidade.Titulo.EmpreendimentoId.GetValueOrDefault() > 0)
{
if (_da.EmpreendimentoCaracterizacaoCARNaoFinalizada(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()))
{
Validacao.Add(Mensagem.CadastroAmbientalRuralTitulo.EmpreendimentoCaracterizacaoCARNaoFinalizada);
return(Validacao.EhValido);
}
}
dependencias = caracterizacaoBus.ObterDependencias(idCaracterizacao, eCaracterizacao.CadastroAmbientalRural, eCaracterizacaoDependenciaTipo.Caracterizacao);
if (caracterizacaoValidar.DependenciasAlteradas(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), (int)eCaracterizacao.CadastroAmbientalRural, eCaracterizacaoDependenciaTipo.Caracterizacao, dependencias) != String.Empty)
{
Validacao.Add(Mensagem.CadastroAmbientalRuralTitulo.CaracterizacaoValida(caracterizacoes.Single(x => x.Tipo == eCaracterizacao.CadastroAmbientalRural).Nome));
}
}
else
{
Validacao.Add(Mensagem.CadastroAmbientalRuralTitulo.CaracterizacaoNaoCadastrada);
}
idCaracterizacao = caracterizacaoBus.Existe(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), eCaracterizacao.Dominialidade);
if (idCaracterizacao > 0)
{
if (_da.EmpreendimentoCaracterizacaoCARNaoFinalizada(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()))
{
Validacao.Add(Mensagem.CadastroAmbientalRuralTitulo.EmpreendimentoCaracterizacaoCARNaoFinalizada);
return(Validacao.EhValido);
}
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.CadastroAmbientalRuralTitulo.CaracterizacaoValida(caracterizacoes.Single(x => x.Tipo == eCaracterizacao.Dominialidade).Nome));
}
}
else
{
Validacao.Add(Mensagem.CadastroAmbientalRuralTitulo.DominialidadeInexistente);
}
#endregion
return(Validacao.EhValido);
}
