Пример #1
0
        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)
        {
            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 static CaracterizacaoPDF ObterDadosCaracterizacoes(IEspecificidade especificidade)
        {
            if (especificidade.Atividades == null || especificidade.Atividades.Count == 0)
            {
                return(new CaracterizacaoPDF());
            }

            if (especificidade.Atividades.Exists(x => x.Id == AtividadeIdSilvicultura || x.Id == AtividadeIdPulverizacao))
            {
                return(ObterDadosCulturas(especificidade));
            }

            List <DependenciaLst>     lstDependencias = ObterDependenciasAtividadesCaract(especificidade);
            List <ICaracterizacaoBus> lstCaractBus    = lstDependencias.Select(x => CaracterizacaoBusFactory.Criar((eCaracterizacao)x.DependenciaTipo)).ToList();

            List <CaracterizacaoPDF> lstCampos = new List <CaracterizacaoPDF>();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
            {
                especificidade.Atividades.ForEach(ativ =>
                {
                    lstCaractBus.ForEach(caractBus =>
                    {
                        /*if (ativ.Id == AtividadeBarragem)
                         * {
                         *      especificidade.TipoDadoCaract = eEspecificidadeDadosCaractTipo.Barragem;
                         *      especificidade.TipoDadoId =
                         * }*/

                        var dado = caractBus.ObterDadosPdfTitulo(especificidade.Titulo.EmpreendimentoId.Value, ativ.Id, especificidade, banco: bancoDeDados);
                        if (dado != null)
                        {
                            lstCampos.Add(dado as CaracterizacaoPDF);
                        }
                    });
                });
            }

            CaracterizacaoPDF caract = new CaracterizacaoPDF();

            if (lstCampos != null && lstCampos.Count > 0)
            {
                var campo = lstCampos.Find(x => !String.IsNullOrEmpty(x.EastingLongitude)) ?? new CaracterizacaoPDF();
                caract.EastingLongitude = campo.EastingLongitude;
                caract.NorthingLatitude = campo.NorthingLatitude;
            }
            caract.Campos = lstCampos.SelectMany(x => x.Campos).ToList();

            caract.Organizar();

            return(caract);
        }
        private static CaracterizacaoPDF ObterDadosCulturas(IEspecificidade especificidade)
        {
            eCaracterizacao eTipoCaracterizacao = eCaracterizacao.Silvicultura;
            int             atividadeId         = AtividadeIdSilvicultura;

            if (especificidade.Atividades.Exists(x => x.Id == AtividadeIdPulverizacao))
            {
                eTipoCaracterizacao = eCaracterizacao.PulverizacaoProduto;
                atividadeId         = AtividadeIdPulverizacao;
            }

            ICaracterizacaoBus caractBus = CaracterizacaoBusFactory.Criar(eTipoCaracterizacao);

            return(caractBus.ObterDadosPdfTitulo(especificidade.Titulo.EmpreendimentoId.Value, atividadeId, especificidade) as CaracterizacaoPDF);
        }
        public 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 ActionResult Index(int id, int projetoDigitalId, bool visualizar = false)
        {
            ProjetoDigitalCredenciadoBus projetoDigitalCredenciadoBus = new ProjetoDigitalCredenciadoBus();

            if (id == 0)
            {
                if (!visualizar)
                {
                    ProjetoDigital projetoDigital = projetoDigitalCredenciadoBus.AlterarEtapa(projetoDigitalId, eProjetoDigitalEtapa.Envio);
                }
                return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
            }

            EmpreendimentoCaracterizacao empreendimento = _bus.ObterEmpreendimentoSimplificado(id);
            CaracterizacaoVM             vm             = new CaracterizacaoVM(empreendimento);

            if (empreendimento.InternoID > 0)
            {
                Empreendimento empreendimentoInterno = new EmpreendimentoInternoBus().ObterSimplificado(empreendimento.InternoID);

                if (empreendimento.InternoTID != empreendimentoInterno.Tid)
                {
                    vm.MensagensNotificacoes.Add(Mensagem.Caracterizacao.EmpreendimentoDesatualizado(empreendimentoInterno.Denominador).Texto);
                }
            }

            if (empreendimento.Id == 0)
            {
                Validacao.Add(Mensagem.Caracterizacao.EmpreendimentoNaoEncontrado);
                return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
            }

            vm.ProjetoDigitalId = projetoDigitalId;
            vm.IsVisualizar     = visualizar;

            List <CaracterizacaoLst> caracterizacoes = _bus.ObterCaracterizacoesPorProjetoDigital(projetoDigitalId);

            if (caracterizacoes.All(carac => carac.Permissao == ePermissaoTipo.NaoPermitido))
            {
                Validacao.Add(Mensagem.Caracterizacao.UsuarioNaoPermitidoParaCaracterizacao);
            }

            caracterizacoes.RemoveAll(caract => caract.Permissao == ePermissaoTipo.NaoPermitido);

            #region Projeto Digital

            if (caracterizacoes == null || caracterizacoes.Count <= 0)
            {
                ProjetoDigital projetoDigital = projetoDigitalCredenciadoBus.AlterarEtapa(projetoDigitalId, eProjetoDigitalEtapa.Envio);

                return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
            }

            ProjetoDigitalCredenciadoValidar projetoDigitalCredenciadoValidar = new ProjetoDigitalCredenciadoValidar();
            if (!projetoDigitalCredenciadoValidar.PossuiCaracterizacaoAtividade(caracterizacoes, projetoDigitalId))
            {
                if (!visualizar)
                {
                    ProjetoDigital projetoDigital = projetoDigitalCredenciadoBus.AlterarEtapa(projetoDigitalId, eProjetoDigitalEtapa.Envio);
                }
                return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
            }
            else
            {
                vm.MostrarFinalizar = (projetoDigitalCredenciadoBus.Obter(projetoDigitalId).Etapa == (int)eProjetoDigitalEtapa.Caracterizacao) && !visualizar;
            }

            #endregion

            List <Caracterizacao> caracterizacoesAssociadas = _bus.ObterCaracterizacoesAssociadasProjetoDigital(projetoDigitalId);
            List <Caracterizacao> cadastradas        = _bus.ObterCaracterizacoesEmpreendimento(id, projetoDigitalId) ?? new List <Caracterizacao>();
            List <Caracterizacao> cadastradasInterno = _internoBus.ObterCaracterizacoesAtuais(empreendimento.InternoID, caracterizacoes);

            if (cadastradas != null && cadastradas.Count > 0)
            {
                List <int> desatualizadas    = new List <int>();
                string     msgDesatualizadas = _validar.CaracterizacoesCadastradasDesatualizadas(empreendimento.Id, cadastradas, cadastradasInterno, out desatualizadas);
                if (!string.IsNullOrEmpty(msgDesatualizadas))
                {
                    vm.MensagensNotificacoes.Add(msgDesatualizadas);
                }
                vm.CaracterizacoesPossivelCopiar = _bus.ObterPossivelCopiar(cadastradas);
                vm.CaracterizacoesPossivelCopiar.AddRange(desatualizadas.Where(x => !vm.CaracterizacoesPossivelCopiar.Exists(y => y == x)));
            }

            vm.CaracterizacoesNaoCadastradas = caracterizacoes
                                               .Where(x => !cadastradas.Any(y => y.Id > 0 && (int)y.Tipo == x.Id))
                                               .Select(z => new CaracterizacaoVME()
            {
                Tipo = (eCaracterizacao)z.Id, Nome = z.Texto
            }).ToList();

            vm.CaracterizacoesCadastradas = caracterizacoes
                                            .Where(x => cadastradas.Where(y => !caracterizacoesAssociadas.Exists(z => z.Tipo == y.Tipo)).Any(y => y.Id > 0 && (int)y.Tipo == x.Id))
                                            .Select(z => new CaracterizacaoVME()
            {
                Tipo = (eCaracterizacao)z.Id, Nome = z.Texto
            }).ToList();

            vm.CaracterizacoesAssociadas = caracterizacoesAssociadas
                                           .Select(z => new CaracterizacaoVME()
            {
                Tipo = (eCaracterizacao)z.Tipo, Nome = z.Nome
            }).ToList();

            List <DependenciaLst> dependencias = _bus.CaracterizacaoConfig.Obter <List <DependenciaLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoesDependencias);

            #region Não Cadastradas

            vm.CaracterizacoesNaoCadastradas.ForEach(x =>
            {
                ICaracterizacaoBus caracterizacaoBus = CaracterizacaoBusFactory.Criar(x.Tipo);
                if (caracterizacaoBus != null)
                {
                    x.PodeCopiar = cadastradasInterno.Exists(y => y.Tipo == x.Tipo) && caracterizacaoBus.PodeCopiar(empreendimento.InternoID);
                }

                x.PodeCadastrar         = User.IsInRole(String.Format("{0}Criar", x.Tipo.ToString()));
                x.ProjetoGeografico     = User.IsInRole("ProjetoGeograficoCriar");
                x.ProjetoGeoObrigatorio = dependencias.Exists(y =>
                                                              y.DependenteTipo == (int)x.Tipo &&
                                                              y.DependenciaTipo == (int)x.Tipo &&
                                                              y.TipoId == (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico);

                x.ProjetoGeograficoId = (cadastradas.FirstOrDefault(y => y.Tipo == x.Tipo) ?? new Caracterizacao()).ProjetoRascunhoId;

                if (x.ProjetoGeograficoId <= 0)
                {
                    x.ProjetoGeograficoId = (cadastradas.SingleOrDefault(y => y.Tipo == x.Tipo) ?? new Caracterizacao()).ProjetoId;
                }

                x.UrlCriar = Url.Action("Criar", x.Tipo.ToString());
            });

            #endregion

            #region Cadastradas

            vm.CaracterizacoesCadastradas.ForEach(x =>
            {
                if (User.IsInRole("ProjetoGeograficoEditar") || User.IsInRole("ProjetoGeograficoVisualizar"))
                {
                    x.ProjetoGeografico = true;
                }

                x.ProjetoGeograficoVisualizar = visualizar;
                x.PodeEditar     = User.IsInRole(String.Format("{0}Editar", x.Tipo.ToString()));
                x.PodeVisualizar = User.IsInRole(String.Format("{0}Visualizar", x.Tipo.ToString()));
                x.PodeExcluir    = (User.IsInRole(String.Format("{0}Excluir", x.Tipo.ToString())) && (x.Tipo == eCaracterizacao.UnidadeConsolidacao || x.Tipo == eCaracterizacao.UnidadeProducao));

                x.PodeCopiar   = cadastradasInterno.Exists(y => y.Tipo == x.Tipo);
                x.PodeAssociar = !caracterizacoesAssociadas.Exists(y => y.Tipo == x.Tipo);

                x.ProjetoGeograficoId = cadastradas.SingleOrDefault(y => y.Tipo == x.Tipo).ProjetoId;

                x.UrlEditar         = Url.Action("Editar", x.Tipo.ToString());
                x.UrlVisualizar     = Url.Action("Visualizar", x.Tipo.ToString());
                x.UrlExcluirConfirm = Url.Action("ExcluirConfirm", x.Tipo.ToString());
                x.UrlExcluir        = Url.Action("Excluir", x.Tipo.ToString());
            });

            #endregion

            #region Associadas

            vm.CaracterizacoesAssociadas.ForEach(x =>
            {
                if (User.IsInRole("ProjetoGeograficoVisualizar"))
                {
                    x.ProjetoGeografico           = true;
                    x.ProjetoGeograficoVisualizar = true;
                    x.ProjetoGeograficoId         = cadastradas.SingleOrDefault(y => y.Tipo == x.Tipo).ProjetoId;
                }

                x.PodeVisualizar = User.IsInRole(String.Format("{0}Visualizar", x.Tipo.ToString()));
                x.UrlVisualizar  = Url.Action("Visualizar", x.Tipo.ToString());
            });

            #endregion

            return(View("Caracterizacao", vm));
        }
Пример #7
0
        public bool FinalizarCaracterizacoes(ProjetoDigital projetoDigital)
        {
            #region Configurar

            List <CaracterizacaoLst> caracterizacoes = _busCaracterizacao.ObterCaracterizacoesPorProjetoDigital(projetoDigital.Id);
            if (caracterizacoes.Count <= 0)
            {
                return(true);
            }

            List <Caracterizacao> lista = new List <Caracterizacao>();
            caracterizacoes.ForEach(r =>
            {
                lista.Add(new Caracterizacao()
                {
                    Tipo = (eCaracterizacao)r.Id
                });
            });

            lista = _busCaracterizacao.ObterCaracterizacoesAtuais(projetoDigital.EmpreendimentoId.GetValueOrDefault(), lista);

            lista.ForEach(r =>
            {
                if (r.Tipo == eCaracterizacao.UnidadeProducao)
                {
                    ICaracterizacaoBus caracterizacaoBus = CaracterizacaoBusFactory.Criar(eCaracterizacao.UnidadeProducao);
                    if (!caracterizacaoBus.PodeEnviar(r.Id))
                    {
                        return;
                    }
                }

                projetoDigital.Dependencias.Add(new Dependencia()
                {
                    DependenciaTipo           = (int)eCaracterizacaoDependenciaTipo.Caracterizacao,
                    DependenciaCaracterizacao = (int)r.Tipo,
                    DependenciaId             = r.Id,
                    DependenciaTid            = r.Tid
                });

                if (r.ProjetoId > 0)
                {
                    projetoDigital.Dependencias.Add(new Dependencia()
                    {
                        DependenciaTipo           = (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico,
                        DependenciaCaracterizacao = (int)r.Tipo,
                        DependenciaId             = r.ProjetoId,
                        DependenciaTid            = r.ProjetoTid
                    });
                }
            });

            #endregion

            if (!Validacao.EhValido)
            {
                return(false);
            }

            AssociarDependencias(projetoDigital);

            List <CaracterizacaoLst> caracterizacoesObrigatorias = _busCaracterizacao.ObterCaracterizacoesPorProjetoDigital(projetoDigital.Id)
                                                                   .Where(x => x.Permissao == ePermissaoTipo.Obrigatorio).ToList();

            List <Dependencia> dependenciasBanco = _da.ObterDependencias(projetoDigital.Id);
            foreach (var item in caracterizacoesObrigatorias)
            {
                if (!dependenciasBanco.Exists(x => x.DependenciaCaracterizacao == item.Id))
                {
                    Validacao.Add(Mensagem.ProjetoDigital.CaracterizacaoObrigatoria(item.Texto));
                }
            }

            return(Validacao.EhValido);
        }
        public bool ValidarTituloGenericoAtividadeCaracterizacao(IEspecificidade especificidade, eEspecificidade tipo = eEspecificidade.Nulo)
        {
            CaracterizacaoBus              busCaracterizacao     = new CaracterizacaoBus();
            GerenciadorConfiguracao        configAtividade       = new GerenciadorConfiguracao(new ConfiguracaoAtividade());
            GerenciadorConfiguracao        configCaracterizacao  = new GerenciadorConfiguracao(new ConfiguracaoCaracterizacao());
            List <AtividadeCaracterizacao> lstAtivCaract         = configAtividade.Obter <List <AtividadeCaracterizacao> >(ConfiguracaoAtividade.KeyAtividadesCaracterizacoes);
            List <Caracterizacao>          lstCaracterizacoes    = busCaracterizacao.ObterCaracterizacoesEmpreendimento(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());
            List <CaracterizacaoLst>       lstCnfCaracterizacoes = configCaracterizacao.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes);
            //List<DependenciaLst> lstCnfDependencias = configCaracterizacao.Obter<List<DependenciaLst>>(ConfiguracaoCaracterizacao.KeyCaracterizacoesDependencias);
            EspecificidadeBusBase _busEspBase = new EspecificidadeBusBase();

            foreach (var item in especificidade.Atividades)
            {
                if (item.Id == 0)
                {
                    continue;
                }

                var ativCaract = lstAtivCaract.FirstOrDefault(x => x.AtividadeId == item.Id);

                if (ativCaract == null || ativCaract.AtividadeId != item.Id || !ativCaract.IsTituloGenerico)
                {
                    EspecificidadeDa _daEsp = new EspecificidadeDa();
                    item.NomeAtividade = _daEsp.ObterAtividadeNome(item.Id);
                    Validacao.Add(Mensagem.Especificidade.AtividadeNaoConfiguradaNaAtividadeCaracte(item.NomeAtividade, especificidade.Titulo.ModeloSigla));
                    continue;
                }

                Caracterizacao     caracterizacao     = lstCaracterizacoes.Find(x => x.Tipo == (eCaracterizacao)ativCaract.CaracterizacaoTipoId);
                CaracterizacaoLst  caracterizacaoTipo = lstCnfCaracterizacoes.Find(x => x.Id == ativCaract.CaracterizacaoTipoId);
                ICaracterizacaoBus busCaract          = CaracterizacaoBusFactory.Criar(caracterizacao.Tipo);

                if (busCaract == null)
                {
                    throw new Exception("CaracterizacaoBusFactory não implementada para o tipo " + caracterizacaoTipo.Texto);
                }

                List <int> atividadesCaract = busCaract.ObterAtividadesCaracterizacao(especificidade.Titulo.EmpreendimentoId.GetValueOrDefault());

                if (atividadesCaract == null || atividadesCaract.Count == 0)
                {
                    Validacao.Add(Mensagem.Especificidade.CaracterizacaoNaoPreenchida(caracterizacaoTipo.Texto));
                    continue;
                }

                if (!atividadesCaract.Exists(x => x == item.Id))
                {
                    Validacao.Add(Mensagem.Especificidade.AtividadeDiferenteCaracterizacao(caracterizacaoTipo.Texto));
                    continue;
                }

                List <Dependencia> lstDependenciaAteradas = busCaracterizacao.ObterDependenciasAlteradas(
                    especificidade.Titulo.EmpreendimentoId.GetValueOrDefault(),
                    caracterizacao.Id,
                    (eCaracterizacao)caracterizacaoTipo.Id,
                    eCaracterizacaoDependenciaTipo.Caracterizacao);

                if (lstDependenciaAteradas != null && lstDependenciaAteradas.Count > 0)
                {
                    Validacao.Add(Mensagem.Especificidade.CaracterizacaoDependencias(caracterizacaoTipo.Texto));

                    /*Validacao.Add(Mensagem.Especificidade.CaracterizacaoDependencias(String.Join(", ", lstDependenciaAteradas.Select(x =>
                     *      String.Format("{0} - {1}",
                     *      lstCnfDependencias.Single(y => y.Id == x.DependenciaTipo).TipoTexto,
                     *      lstCnfCaracterizacoes.Single(y => y.Id == x.DependenciaCaracterizacao).Texto)
                     * ).ToArray())));*/
                }
            }

            switch (tipo)
            {
            case eEspecificidade.LicencaAmbientalRegularizacao:
            case eEspecificidade.LicencaAmbientalUnica:
            case eEspecificidade.LicencaSimplificada:
            case eEspecificidade.LicencaInstalacao:
            case eEspecificidade.LicencaOperacao:
            case eEspecificidade.LicencaPrevia:
                if (especificidade.Atividades.Count > 0)
                {
                    especificidade.AtividadeCaractTipo =
                        (eAtividadeCodigo)ConfiguracaoAtividade.ObterCodigo(especificidade.Atividades[0].Id);
                }

                switch (especificidade.AtividadeCaractTipo)
                {
                case eAtividadeCodigo.Barragem:
                    var configEspAtivCaract = _busEspBase.GetConfigAtivEspCaracterizacao((int)tipo);
                    var list = configEspAtivCaract.GetListValue <int>("Atividades");

                    if (especificidade is ILicenca && list.Where(x => x == (int)eAtividadeCodigo.Barragem).ToList().Count > 0)
                    {
                        _validarLicenca.Validar(especificidade as ILicenca);
                    }

                    break;
                }
                break;
            }
            return(Validacao.EhValido);
        }