public string AbrirModalAcessar(int empreendimentoId)
        {
            EmpreendimentoCaracterizacao empreendimento = _caracterizacaoBus.ObterEmpreendimentoSimplificado(empreendimentoId);

            if (empreendimento.ZonaLocalizacao == eZonaLocalizacao.Rural)
            {
                DominialidadeDa dominialidadeDa = new DominialidadeDa();
                Dominialidade   dominialidade   = dominialidadeDa.ObterPorEmpreendimento(empreendimentoId);

                foreach (Dominio dominio in dominialidade.Dominios)
                {
                    if (dominio.ReservasLegais.Exists(x => x.SituacaoId == (int)eReservaLegalSituacao.NaoInformada))
                    {
                        return(Mensagem.ExploracaoFlorestal.EmpreendimentoRuralReservaIndefinida.Texto);
                    }
                }
            }

            return(string.Empty);
        }
        public 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);
        }
Example #3
0
        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 object ObterDadosPdf(IEspecificidade especificidade, BancoDeDados banco)
        {
            try
            {
                Cadastro cadastro = _da.ObterDadosPDF(especificidade.Titulo.Id, banco);
                CadastroAmbientalRuralBus carBus = new CadastroAmbientalRuralBus();

                cadastro.CAR           = new CadastroAmbientalRuralPDF(carBus.ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(), true));
                cadastro.Dominialidade = new DominialidadePDF(new DominialidadeBus().ObterPorEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault()));

                if (cadastro.Dominialidade.IsEmpreendimentoCedente && cadastro.Dominialidade.IsEmpreendimentoReceptor)
                {
                    cadastro.CAR.TipoCompensacao = "CEDENTE E RECEPTOR";
                }
                else if (cadastro.Dominialidade.IsEmpreendimentoCedente)
                {
                    cadastro.CAR.TipoCompensacao = "CEDENTE";
                }
                else if (cadastro.Dominialidade.IsEmpreendimentoReceptor)
                {
                    cadastro.CAR.TipoCompensacao = "RECEPTOR";
                }

                #region Solicitacao CAR

                //Interno
                cadastro.SICAR = _da.ObterSICARInterno(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(0), banco) ?? new SicarPDF();

                if (String.IsNullOrWhiteSpace(cadastro.SICAR.Numero))
                {
                    cadastro.SICAR = _da.ObterSICARCredenciado(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(0), banco) ?? new SicarPDF();
                }

                #endregion

                #region Arl Compensadas

                cadastro.Dominialidade.Dominios.ForEach(d =>
                {
                    List <ReservaLegalPDF> rlCompensadas = d.ReservasLegais.Where(r => r.CompensacaoTipo != eCompensacaoTipo.Nulo).ToList();

                    foreach (var reservaLegal in rlCompensadas)
                    {
                        string identificacao             = string.Empty;
                        string areaCroqui                = string.Empty;
                        string coordenadaE               = string.Empty;
                        string coordenadaN               = string.Empty;
                        eCompensacaoTipo compensacaoTipo = eCompensacaoTipo.Nulo;

                        if (reservaLegal.CompensacaoTipo.Equals(eCompensacaoTipo.Cedente))
                        {
                            compensacaoTipo = eCompensacaoTipo.Cedente;
                            identificacao   = reservaLegal.Identificacao;
                            areaCroqui      = reservaLegal.ARLCroqui;
                            coordenadaE     = reservaLegal.Coordenada.EastingUtm.ToString();
                            coordenadaN     = reservaLegal.Coordenada.NorthingUtm.ToString();
                        }
                        else if (reservaLegal.CompensacaoTipo.Equals(eCompensacaoTipo.Receptora))
                        {
                            compensacaoTipo = eCompensacaoTipo.Receptora;

                            if (reservaLegal.IdentificacaoARLCedente > 0)
                            {
                                var reservaLegalReceptora = new DominialidadeDa().ObterARLPorId(reservaLegal.IdentificacaoARLCedente);

                                identificacao = reservaLegalReceptora.Identificacao;
                                areaCroqui    = reservaLegalReceptora.ARLCroqui.ToStringTrunc();
                                coordenadaE   = reservaLegalReceptora.Coordenada.EastingUtm.ToString();
                                coordenadaN   = reservaLegalReceptora.Coordenada.NorthingUtm.ToString();
                            }
                            else
                            {
                                areaCroqui  = reservaLegal.ARLCroqui;
                                coordenadaE = reservaLegal.Coordenada.EastingUtm.ToString();
                                coordenadaN = reservaLegal.Coordenada.NorthingUtm.ToString();
                            }
                        }

                        if (string.IsNullOrWhiteSpace(areaCroqui))
                        {
                            continue;
                        }

                        cadastro.CAR.TotalRLCompensadaDecimal += Convert.ToDecimal(areaCroqui);

                        cadastro.RLCompensada.Add(new AreaReservaLegalPDF()
                        {
                            CompensacaoTipo = (int)compensacaoTipo,
                            Tipo            = reservaLegal.SituacaoVegetalId,
                            Codigo          = reservaLegal.EmpreendimentoCompensacao.Codigo,
                            AreaCroqui      = areaCroqui,
                            CoordenadaE     = coordenadaE,
                            CoordenadaN     = coordenadaN,
                            Identificacao   = identificacao
                        });
                    }
                });

                #endregion

                #region Croqui
                List <ArquivoProjeto> arquivosProj = carBus.ObterArquivosProjeto(cadastro.CAR.ProjetoGeoId, true).Where(x => x.Tipo == (int)eProjetoGeograficoArquivoTipo.Croqui).ToList();
                cadastro.AnexosPdfs = arquivosProj.Cast <Arquivo>().ToList();

                //Obtendo Arquivos
                ArquivoBus _busArquivo = new ArquivoBus(eExecutorTipo.Interno);
                for (int i = 0; i < cadastro.AnexosPdfs.Count; i++)
                {
                    cadastro.AnexosPdfs[i] = _busArquivo.ObterDados(cadastro.AnexosPdfs[i].Id.GetValueOrDefault(0));
                }
                #endregion

                String pathImg = HttpContext.Current.Request.MapPath("~/Content/_imgLogo/logomarca_simlam_idaf.jpg");
                cadastro.LogoOrgao = File.ReadAllBytes(pathImg);
                cadastro.LogoOrgao = AsposeImage.RedimensionarImagem(cadastro.LogoOrgao, 2.2f);

                GerenciadorConfiguracao <ConfiguracaoSistema>     _configSys  = new GerenciadorConfiguracao <ConfiguracaoSistema>(new ConfiguracaoSistema());
                GerenciadorConfiguracao <ConfiguracaoFuncionario> _configFunc = new GerenciadorConfiguracao <ConfiguracaoFuncionario>(new ConfiguracaoFuncionario());

                cadastro.GovernoNome    = _configSys.Obter <String>(ConfiguracaoSistema.KeyGovernoNome);
                cadastro.SecretariaNome = _configSys.Obter <String>(ConfiguracaoSistema.KeySecretariaNome);
                cadastro.OrgaoNome      = _configSys.Obter <String>(ConfiguracaoSistema.KeyOrgaoNome);
                cadastro.SetorNome      = _configFunc.Obter <List <Setor> >(ConfiguracaoFuncionario.KeySetores).Single(x => x.Id == especificidade.Titulo.SetorId).Nome;

                return(cadastro);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(null);
        }