Subversion Repositories Integrator Subversion

package br.gov.al.saude.srv.web.managebean.servidor;

import static br.gov.al.saude.framework.core.util.VerificadorUtil.estaNulo;
import static br.gov.al.saude.framework.core.util.VerificadorUtil.estaNuloOuVazio;
import static br.gov.al.saude.framework.core.util.VerificadorUtil.naoEstaNulo;
import static br.gov.al.saude.framework.core.util.VerificadorUtil.naoEstaNuloOuVazio;
import static br.gov.al.saude.framework.web.util.ConstantesWebHelper.IdentificadorMensagem.IDENTIFICADOR_MENSAGEM_ALTERADO_COM_SUCESSO;
import static br.gov.al.saude.srv.core.domain.servidor.ServidorService.PAPEL_SERVIDOR;
import static br.gov.al.saude.srv.core.domain.servidor.ServidorService.PAPEL_SERVIDOR_TECNICO_CSGDP;
import static br.gov.al.saude.srv.core.domain.servidor.ServidorService.PAPEL_SERVIDOR_TECNICO_SAD;
import static br.gov.al.saude.srv.core.domain.servidor.ServidorService.PAPEL_SERVIDOR_TECNICO_SAFP;
import static br.gov.al.saude.srv.core.domain.servidor.ServidorService.PAPEL_SERVIDOR_TECNICO_SER;
import static br.gov.al.saude.srv.core.domain.servidor.ServidorService.PAPEL_SERVIDOR_TECNICO_SIF;
import static br.gov.al.saude.srv.model.FormaIngresso.FORMA_INGRESSO_ESTAGIARIO;
import static br.gov.al.saude.srv.model.FormaIngresso.FORMA_INGRESSO_PRESTADOR;
import static br.gov.al.saude.srv.model.FormaIngresso.FORMA_INGRESSO_PROCESSO_SELETIVO;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import javax.faces.bean.ManagedBean;
import javax.faces.context.FacesContext;
import javax.imageio.stream.FileImageOutputStream;
import javax.servlet.ServletContext;

import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperPrint;

import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.filefilter.WildcardFileFilter;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.model.CroppedImage;
import org.primefaces.model.DefaultStreamedContent;
import org.primefaces.model.StreamedContent;
import org.primefaces.model.UploadedFile;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.util.DigestUtils;

import br.gov.al.saude.framework.core.exception.RelatorioException;
import br.gov.al.saude.framework.core.generic.GenericFacade;
import br.gov.al.saude.framework.core.interfaces.Cadastrar;
import br.gov.al.saude.framework.core.model.pessoa.PessoaDTO;
import br.gov.al.saude.framework.core.util.StringUtils;
import br.gov.al.saude.framework.core.validador.Validador;
import br.gov.al.saude.framework.model.PessoaDocumentoView;
import br.gov.al.saude.framework.model.PessoaFisicaView;
import br.gov.al.saude.framework.model.PessoaTelefoneView;
import br.gov.al.saude.framework.model.SetorView;
import br.gov.al.saude.framework.model.UfView;
import br.gov.al.saude.framework.model.UsuarioView;
import br.gov.al.saude.framework.web.exception.VerificadorLancamentoException;
import br.gov.al.saude.framework.web.exception.VerificadorLancamentoException.CommandBean;
import br.gov.al.saude.framework.web.generic.AbstractBeanComModalScg;
import br.gov.al.saude.framework.web.generic.GenericConsultaDemanda;
import br.gov.al.saude.framework.web.message.LancadorMensagem;
import br.gov.al.saude.framework.web.model.ModelCampoCombo;
import br.gov.al.saude.srv.core.application.banco.BancoFacade;
import br.gov.al.saude.srv.core.application.cargo.CargoFacade;
import br.gov.al.saude.srv.core.application.carreira.CarreiraFacade;
import br.gov.al.saude.srv.core.application.conselho.ConselhoFacade;
import br.gov.al.saude.srv.core.application.cursoestagio.CursoEstagioFacade;
import br.gov.al.saude.srv.core.application.deficiencia.DeficienciaFacade;
import br.gov.al.saude.srv.core.application.especialidade.EspecialidadeFacade;
import br.gov.al.saude.srv.core.application.formaingresso.FormaIngressoFacade;
import br.gov.al.saude.srv.core.application.funcao.FuncaoFacade;
import br.gov.al.saude.srv.core.application.grauinstrucao.GrauInstrucaoFacade;
import br.gov.al.saude.srv.core.application.instituicaoestagio.InstituicaoEstagioFacade;
import br.gov.al.saude.srv.core.application.nacionalidade.NacionalidadeFacade;
import br.gov.al.saude.srv.core.application.ordenador.Ordenador;
import br.gov.al.saude.srv.core.application.ordenador.impl.OrdenadorImpl;
import br.gov.al.saude.srv.core.application.orgao.OrgaoFacade;
import br.gov.al.saude.srv.core.application.servidor.ServidorFacade;
import br.gov.al.saude.srv.core.application.setorview.SetorViewFacade;
import br.gov.al.saude.srv.core.application.situacaoservidor.SituacaoServidorFacade;
import br.gov.al.saude.srv.core.application.uf.UfFacade;
import br.gov.al.saude.srv.core.application.unidade.UnidadeFacade;
import br.gov.al.saude.srv.model.Banco;
import br.gov.al.saude.srv.model.Cargo;
import br.gov.al.saude.srv.model.Carreira;
import br.gov.al.saude.srv.model.Conselho;
import br.gov.al.saude.srv.model.CursoEstagio;
import br.gov.al.saude.srv.model.Deficiencia;
import br.gov.al.saude.srv.model.Especialidade;
import br.gov.al.saude.srv.model.FormaIngresso;
import br.gov.al.saude.srv.model.Funcao;
import br.gov.al.saude.srv.model.GrauInstrucao;
import br.gov.al.saude.srv.model.InstituicaoEstagio;
import br.gov.al.saude.srv.model.Nacionalidade;
import br.gov.al.saude.srv.model.Orgao;
import br.gov.al.saude.srv.model.Servidor;
import br.gov.al.saude.srv.model.ServidorContaBancaria;
import br.gov.al.saude.srv.model.ServidorDadoFuncional;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalConselho;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalContratado;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalContratadoEstagiario;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalMatricula;
import br.gov.al.saude.srv.model.ServidorDadoFuncionalMatriculaCarreira;
import br.gov.al.saude.srv.model.ServidorDependente;
import br.gov.al.saude.srv.model.ServidorLocalizacaoArquivo;
import br.gov.al.saude.srv.model.ServidorQualificacao;
import br.gov.al.saude.srv.model.SituacaoServidor;
import br.gov.al.saude.srv.model.Unidade;
import br.gov.al.saude.srv.model.dto.CargoDTO;
import br.gov.al.saude.srv.model.dto.FuncaoDTO;
import br.gov.al.saude.srv.model.dto.ParametroConsultaCargoDTO;
import br.gov.al.saude.srv.model.dto.ParametroConsultaFuncaoDTO;
import br.gov.al.saude.srv.model.dto.ParametroConsultaServidorDTO;
import br.gov.al.saude.srv.model.dto.ServidorDTO;
import br.gov.al.saude.srv.model.embedded.ServidorContaBancarialId;
import br.gov.al.saude.srv.model.enums.TipoClasseCarreira;
import br.gov.al.saude.srv.model.enums.TipoNivelCarreira;
import br.gov.al.saude.srv.model.enums.TipoNivelEstagio;
import br.gov.al.saude.srv.model.enums.TipoRegimeTrabalho;
import br.gov.al.saude.srv.model.enums.TipoSituacaoCadastral;
import br.gov.al.saude.srv.model.enums.TipoVinculo;

@Component
@ManagedBean
@Scope("view")
public class ServidorBean extends AbstractBeanComModalScg<Servidor> implements Serializable {

        private static final long serialVersionUID = 1L;
       
        private ServidorFacade servidorFacade;
        private FormaIngressoFacade formaIngressoFacade;
        private UnidadeFacade unidadeFacade;
        private FuncaoFacade funcaoFacade;
        private CargoFacade cargoFacade;
        private InstituicaoEstagioFacade instituicaoEstagioFacade;
        private CursoEstagioFacade cursoEstagioFacade;

        private List<PessoaDocumentoView> listaDocumento;
        private List<PessoaTelefoneView> listaTelefone;
        private PessoaDocumentoView documentoSelecionado;
       
        private List<ServidorDadoFuncional> listaDadosFuncionais;
        private ServidorDadoFuncional dadoFuncionalSelecionado;
        private ServidorDadoFuncionalMatricula dadoFuncionalMatricula;
        private ServidorDadoFuncionalMatriculaCarreira dadoFuncionalMatriculaCarreira;
        private ServidorDadoFuncionalContratadoEstagiario dadoFuncionalContratadoEstagiario;
        private ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo dadoFuncionalContratadoPrestadorProcessoSeletivo;
       
        private ServidorDadoFuncional dadoFuncionalSelecionadoDetalhar;
        private ServidorDadoFuncionalMatricula dadoFuncionalMatriculaDetalhar;
        private ServidorDadoFuncionalMatriculaCarreira dadoFuncionalMatriculaCarreiraDetalhar;
        private ServidorDadoFuncionalContratadoEstagiario dadoFuncionalContratadoEstagiarioDetalhar;
        private ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo dadoFuncionalContratadoPrestadorProcessoSeletivoDetalhar;
        private Boolean cadastrarDadoFuncional;
       
        private List<ServidorContaBancaria> listaContasBancarias;
        private ServidorContaBancaria contaBancariaSelecionada;
        private Boolean cadastrarContaBancaria;
       
        private List<ServidorDependente> listaDependentes;
        private ServidorDependente dependenteSelecionado;
        private Boolean cadastrarDependente;
       
        private List<ServidorQualificacao> listaQualificacoes;
        private ServidorQualificacao qualificacaoSelecionada;
        private Boolean cadastrarQualificacao;
       
        private ParametroConsultaServidorDTO parametro;
       
        private ServidorLocalizacaoArquivo servidorLocalizacaoArquivoSelecionado;
        private ServidorDadoFuncionalConselho servidorDadoFuncionalConselho;

        private Servidor servidorSelecionado;

        private Boolean cadastrarPessoa;
        private Boolean servidorDados;
        private Boolean consultarServidor;
        private Boolean consultaDesabilitada;
       
        private ConsultaServidorPorDemanda lazy;
        private ConsultaFuncaoDTOPorDemanda lazyFuncaoDTO;
        private ConsultaCargoDTOPorDemanda lazyCargoDTO;
       
        private Ordenador ordenador;
        private Validador validador;

        private String tipoSituacaoCadastral = "";
        private List<ModelCampoCombo> listaTipoSituacaoCadastral;
       
        private List<TipoVinculo> listaTiposVinculo;
        private TipoVinculo tipoVinculoSelecionado;
        private List<FormaIngresso> listaFormasIngresso;
        private FormaIngresso formaIngressoSelecionada;
        private List<Unidade> listaUnidadesAtivas;
        private Funcao funcaoConsulta;
        private Cargo cargoConsulta;
        private List<InstituicaoEstagio> listaInstituicaoEstagio;
        private List<CursoEstagio> listaCursoEstagio;
        private List<ModelCampoCombo> listaNivelEstagio;
        private List<ModelCampoCombo> listaCargaHoraria;
       
        private UploadedFile fotoUpload;
        private CroppedImage fotoRecortada;
        private String nomeArquivoFoto;
       
        /* antigo Ficha Cadastral Bean */
        private GrauInstrucaoFacade grauInstrucaoFacade;
        private NacionalidadeFacade nacionalidadeFacade;
        private DeficienciaFacade deficienciaFacade;
        private SituacaoServidorFacade situacaoServidorFacade;
        private EspecialidadeFacade especialidadeFacade;
        private OrgaoFacade orgaoExternoFacade;
        private CarreiraFacade carreiraFacade;
        private SetorViewFacade setorViewFacade;
        private ConselhoFacade conselhoFacade;
        private UfFacade ufFacade;
        private BancoFacade bancoFacade;
       
        private List<GrauInstrucao> listaGrauInstrucao;
        private List<Nacionalidade> listaNacionalidade;
        private List<Deficiencia> listaDeficiencia;
        private List<SituacaoServidor> listaSituacaoServidor;
        private List<Especialidade> listaEspecialidade;
        private List<Orgao> listaOrgao;
        private List<Carreira> listaCarreira;
        private List<SetorView> listaSetorView;
        private List<Conselho> listaConselho;
        private List<UfView> listaUfView;
        private List<Banco> listaBanco;
        private List<ModelCampoCombo> listaTipoClasseCarreira;
        private List<ModelCampoCombo> listaTipoRegimeTrabalho;
        private List<ModelCampoCombo> listaTipoNivelCarreira;
       
        private Boolean listasInicializadas;

        @Autowired
        public ServidorBean(ServidorFacade servidorFacade, ConsultaServidorPorDemanda lazy, FormaIngressoFacade formaIngressoFacade, UnidadeFacade unidadeFacade,
                        FuncaoFacade funcaoFacade, CargoFacade cargoFacade, InstituicaoEstagioFacade instituicaoEstagioFacade, CursoEstagioFacade cursoEstagioFacade,
                        Validador validador, ConsultaFuncaoDTOPorDemanda lazyFuncaoDTO, ConsultaCargoDTOPorDemanda lazyCargoDTO,
                        GrauInstrucaoFacade grauInstrucaoFacade, NacionalidadeFacade nacionalidadeFacade, DeficienciaFacade deficienciaFacade,
                        SituacaoServidorFacade situacaoServidorFacade, EspecialidadeFacade especialidadeFacade, OrgaoFacade orgaoFacade,  
                        CarreiraFacade carreiraFacade, SetorViewFacade setorViewFacade, ConselhoFacade conselhoFacade, UfFacade ufFacade, BancoFacade bancoFacade) {

                this.servidorFacade = servidorFacade;
                this.formaIngressoFacade = formaIngressoFacade;
                this.unidadeFacade = unidadeFacade;
                this.funcaoFacade = funcaoFacade;
                this.cargoFacade = cargoFacade;
                this.instituicaoEstagioFacade = instituicaoEstagioFacade;
                this.cursoEstagioFacade = cursoEstagioFacade;
                this.lazy = lazy;
                this.lazyFuncaoDTO = lazyFuncaoDTO;
                this.lazyCargoDTO = lazyCargoDTO;
                this.ordenador = new OrdenadorImpl();
                this.validador = validador;
                setCadastrarPessoa(false);
                setServidorDados(false);
                setConsultarServidor(true);
                consultaDesabilitada = false;
               
                this.grauInstrucaoFacade = grauInstrucaoFacade;
                this.nacionalidadeFacade = nacionalidadeFacade;
                this.deficienciaFacade = deficienciaFacade;
                this.situacaoServidorFacade = situacaoServidorFacade;
                this.especialidadeFacade = especialidadeFacade;
                this.orgaoExternoFacade = orgaoFacade;
                this.carreiraFacade = carreiraFacade;
                this.setorViewFacade = setorViewFacade;
                this.conselhoFacade = conselhoFacade;
                this.ufFacade = ufFacade;
                this.bancoFacade = bancoFacade;
                listasInicializadas = false;
        }
       
        @Override
        public Servidor getEntidade() {
                if (estaNulo(entidade)) {
                        setEntidade(new Servidor());
                }
                return entidade;
        }

        @Override
        public GenericFacade<Servidor> getFacade() {
                return servidorFacade;
        }

        @Override
        public Object getId() {
                return getEntidade().getId();
        }

        @Override
        public String getTelaCrud() {
                return "/paginas/index.xhtml";
        }

        @Override
        public void limparEntidade() {
                entidade = new Servidor();
        }
       
        @Override
        public GenericConsultaDemanda<Servidor> getLazy() {
                return null;
        }
       
        public ConsultaServidorPorDemanda getLazyDTO() {
                return this.lazy;
        }
       
        public ConsultaFuncaoDTOPorDemanda getLazyFuncaoDTO() {
                return this.lazyFuncaoDTO;
        }
       
        public ConsultaCargoDTOPorDemanda getLazyCargoDTO() {
                return this.lazyCargoDTO;
        }
       
        @Override
        protected void modificarEntidadeAntesDaOperacao() {
                atribuirListasAhEntidade();
                atribuirLocalizacaoArquivoCasoTenhaSidoPreenchida();
                if (estaNuloOuVazio(getServidorSelecionado().getUsuario())) {
                        UsuarioView usuario = new UsuarioView();
                        usuario.setSequencialPessoa(getSequencialPessoaUsuarioLogado());
                        getServidorSelecionado().setUsuario(usuario);
                }
        }

        private void atribuirListasAhEntidade() {
                getServidorSelecionado().getPessoa().getDocumentos().clear();
                getServidorSelecionado().getPessoa().getDocumentos().addAll(getListaDocumento());
               
                getServidorSelecionado().getListaServidorDadoFuncional().clear();
                getServidorSelecionado().getListaServidorDadoFuncional().addAll(getListaDadosFuncionais());
               
                getServidorSelecionado().getListaServidorContaBancaria().clear();
                getServidorSelecionado().getListaServidorContaBancaria().addAll(getListaContasBancarias());
               
                getServidorSelecionado().getListaServidorDependente().clear();
                getServidorSelecionado().getListaServidorDependente().addAll(getListaDependentes());
               
                getServidorSelecionado().getListaServidorQualificacao().clear();
                getServidorSelecionado().getListaServidorQualificacao().addAll(getListaQualificacoes());
        }
       
        private void atribuirLocalizacaoArquivoCasoTenhaSidoPreenchida() {
                if(servidorLocalizacaoArquivoFoiPreenchido()) {
                        getServidorSelecionado().setServidorLocalizacaoArquivo(getServidorLocalizacaoArquivoSelecionado());
                        getServidorLocalizacaoArquivoSelecionado().setServidor(getServidorSelecionado());
                } else {
                        getServidorSelecionado().setServidorLocalizacaoArquivo(null);
                }
        }
       
        private Boolean servidorLocalizacaoArquivoFoiPreenchido() {
                return naoEstaNuloOuVazio(getServidorLocalizacaoArquivoSelecionado().getNumeroCaixa())
                                || naoEstaNuloOuVazio(getServidorLocalizacaoArquivoSelecionado().getNumeroPasta())
                                || naoEstaNuloOuVazio(getServidorLocalizacaoArquivoSelecionado().getNumeroPrateleira())
                                || naoEstaNuloOuVazio(getServidorLocalizacaoArquivoSelecionado().getTipoLado());
        }

        public List<PessoaDocumentoView> getListaDocumento() {
                if (listaDocumento == null) {
                        listaDocumento = new ArrayList<PessoaDocumentoView>();
                        if(getServidorSelecionado() != null) {
                                listaDocumento.addAll(getServidorSelecionado().getListaDocumentosDePessoa());
                        }
                }
                return listaDocumento;
        }
       
        public void setListaDocumento(List<PessoaDocumentoView> listaDocumento) {
                this.listaDocumento = listaDocumento;
        }
       
        public List<PessoaTelefoneView> getListaTelefone() {
                if (listaTelefone == null) {
                        listaTelefone = new ArrayList<PessoaTelefoneView>();
                        if(getServidorSelecionado() != null) {
                                listaTelefone.addAll(getServidorSelecionado().getPessoa().getTelefones());
                        }
                }
               
                return listaTelefone;
        }

        public void setListaTelefone(List<PessoaTelefoneView> listaTelefone) {
                this.listaTelefone = listaTelefone;
        }

        public List<ServidorDadoFuncional> getListaDadosFuncionais() {
                if (listaDadosFuncionais == null) {
                        listaDadosFuncionais = new ArrayList<ServidorDadoFuncional>();
                        if(getServidorSelecionado() != null) {
                                listaDadosFuncionais.addAll(getServidorSelecionado().getListaServidorDadoFuncional());
                        }
                }
                return listaDadosFuncionais;
        }
        public void setListaDadosFuncionais(List<ServidorDadoFuncional> listaDadosFuncionais) {
                this.listaDadosFuncionais = listaDadosFuncionais;
        }
       
        public List<ServidorContaBancaria> getListaContasBancarias() {
                if (listaContasBancarias == null) {
                        listaContasBancarias = new ArrayList<ServidorContaBancaria>();
                        if(getServidorSelecionado() != null) {
                                listaContasBancarias.addAll(getServidorSelecionado().getListaServidorContaBancaria());
                        }
                }
                return listaContasBancarias;
        }
        public void setListaContasBancarios(List<ServidorContaBancaria> listaContasBancarias) {
                this.listaContasBancarias = listaContasBancarias;
        }
       
        public List<ServidorDependente> getListaDependentes() {
                if (listaDependentes == null) {
                        listaDependentes = new ArrayList<ServidorDependente>();
                        if(getServidorSelecionado() != null) {
                                listaDependentes.addAll(getServidorSelecionado().getListaServidorDependente());
                        }
                }
                return listaDependentes;
        }
        public void setListaDependentes(List<ServidorDependente> listaDependentes) {
                this.listaDependentes = listaDependentes;
        }
       
        public List<ServidorQualificacao> getListaQualificacoes() {
                if (listaQualificacoes == null) {
                        listaQualificacoes = new ArrayList<ServidorQualificacao>();
                        if(getServidorSelecionado() != null) {
                                listaQualificacoes.addAll(ordenador.ordenar(getServidorSelecionado().getListaServidorQualificacao()));
                        }
                }
                return listaQualificacoes;
        }
        public void setListaQualificacoes(List<ServidorQualificacao> listaQualificacoes) {
                this.listaQualificacoes = listaQualificacoes;
        }
       
        public PessoaDocumentoView getDocumentoSelecionado() {
                return documentoSelecionado;
        }
        public void setDocumentoSelecionado(PessoaDocumentoView documentoSelecionado) {
                this.documentoSelecionado = documentoSelecionado;
        }
       
        public void setarDadoFuncionalDeAcordoComTipoVinculoEeFormaIngresso() {
                dadoFuncionalMatricula = null;
                dadoFuncionalMatriculaCarreira = null;
                dadoFuncionalContratadoEstagiario = null;
                dadoFuncionalContratadoPrestadorProcessoSeletivo = null;
               
                if(getTipoVinculoSelecionado().equals(TipoVinculo.EFETIVO) || getTipoVinculoSelecionado().equals(TipoVinculo.CELETISTA)) {
                        dadoFuncionalMatriculaCarreira = new ServidorDadoFuncionalMatriculaCarreira();
                        setDadoFuncionalSelecionado(dadoFuncionalMatriculaCarreira);
                }
                if(getTipoVinculoSelecionado().equals(TipoVinculo.COMISSIONADO)) {
                        dadoFuncionalMatricula = new ServidorDadoFuncionalMatricula();
                        setDadoFuncionalSelecionado(dadoFuncionalMatricula);
                }
                if(getTipoVinculoSelecionado().equals(TipoVinculo.CONTRATADO)) {
                        if(getFormaIngressoSelecionada().getCodigo().equals(FORMA_INGRESSO_ESTAGIARIO)) {
                                dadoFuncionalContratadoEstagiario = new ServidorDadoFuncionalContratadoEstagiario();
                                setDadoFuncionalSelecionado(dadoFuncionalContratadoEstagiario);
                        }
                        if(getFormaIngressoSelecionada().getCodigo().equals(FORMA_INGRESSO_PRESTADOR) || getFormaIngressoSelecionada().getCodigo().equals(FORMA_INGRESSO_PROCESSO_SELETIVO)) {
                                dadoFuncionalContratadoPrestadorProcessoSeletivo = new ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo();
                                setDadoFuncionalSelecionado(dadoFuncionalContratadoPrestadorProcessoSeletivo);
                        }
                }
                getDadoFuncionalSelecionado().setServidorDadoFuncionalConselho(new ServidorDadoFuncionalConselho());
        }
       
        public ServidorDadoFuncional getDadoFuncionalSelecionado() {
                if (estaNulo(dadoFuncionalSelecionado)) {
                        dadoFuncionalSelecionado = new ServidorDadoFuncional();
                }
                return dadoFuncionalSelecionado;
        }
       
        public void setDadoFuncionalSelecionado(ServidorDadoFuncional dadoFuncionalSelecionado) {
                this.dadoFuncionalSelecionado = dadoFuncionalSelecionado;
        }
       
        public ServidorDadoFuncional getDadoFuncionalSelecionadoDetalhar() {
                if (estaNulo(dadoFuncionalSelecionadoDetalhar)) {
                        dadoFuncionalSelecionadoDetalhar = new ServidorDadoFuncional();
                }
                return dadoFuncionalSelecionadoDetalhar;
        }
       
        public void setDadoFuncionalSelecionadoDetalhar(ServidorDadoFuncional dadoFuncionalSelecionado) {
                this.dadoFuncionalSelecionadoDetalhar = dadoFuncionalSelecionado;
        }

        public ServidorDadoFuncionalMatricula getDadoFuncionalMatricula() {
                return dadoFuncionalMatricula;
        }

        public void setDadoFuncionalMatricula(ServidorDadoFuncionalMatricula dadoFuncional) {
                this.dadoFuncionalMatricula = dadoFuncional;
        }

        public ServidorDadoFuncionalMatriculaCarreira getDadoFuncionalMatriculaCarreira() {
                return dadoFuncionalMatriculaCarreira;
        }

        public void setDadoFuncionalMatriculaCarreira(ServidorDadoFuncionalMatriculaCarreira dadoFuncional) {
                this.dadoFuncionalMatriculaCarreira = dadoFuncional;
        }

        public ServidorDadoFuncionalContratadoEstagiario getDadoFuncionalContratadoEstagiario() {
                return dadoFuncionalContratadoEstagiario;
        }

        public void setDadoFuncionalContratadoEstagiario(ServidorDadoFuncionalContratadoEstagiario dadoFuncional) {
                this.dadoFuncionalContratadoEstagiario = dadoFuncional;
        }

        public ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo getDadoFuncionalContratadoPrestadorProcessoSeletivo() {
                return dadoFuncionalContratadoPrestadorProcessoSeletivo;
        }

        public void setDadoFuncionalContratadoPrestadorProcessoSeletivo(ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo dadoFuncional) {
                this.dadoFuncionalContratadoPrestadorProcessoSeletivo = dadoFuncional;
        }
       
        public ServidorDadoFuncionalMatricula getDadoFuncionalMatriculaDetalhar() {
                return dadoFuncionalMatriculaDetalhar;
        }

        public void setDadoFuncionalMatriculaDetalhar(ServidorDadoFuncionalMatricula dadoFuncional) {
                this.dadoFuncionalMatriculaDetalhar = dadoFuncional;
        }

        public ServidorDadoFuncionalMatriculaCarreira getDadoFuncionalMatriculaCarreiraDetalhar() {
                return dadoFuncionalMatriculaCarreiraDetalhar;
        }

        public void setDadoFuncionalMatriculaCarreiraDetalhar(ServidorDadoFuncionalMatriculaCarreira dadoFuncional) {
                this.dadoFuncionalMatriculaCarreiraDetalhar = dadoFuncional;
        }

        public ServidorDadoFuncionalContratadoEstagiario getDadoFuncionalContratadoEstagiarioDetalhar() {
                return dadoFuncionalContratadoEstagiarioDetalhar;
        }

        public void setDadoFuncionalContratadoEstagiarioDetalhar(ServidorDadoFuncionalContratadoEstagiario dadoFuncional) {
                this.dadoFuncionalContratadoEstagiarioDetalhar = dadoFuncional;
        }

        public ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo getDadoFuncionalContratadoPrestadorProcessoSeletivoDetalhar() {
                return dadoFuncionalContratadoPrestadorProcessoSeletivoDetalhar;
        }

        public void setDadoFuncionalContratadoPrestadorProcessoSeletivoDetalhar(ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo dadoFuncional) {
                this.dadoFuncionalContratadoPrestadorProcessoSeletivoDetalhar = dadoFuncional;
        }

        public ServidorContaBancaria getContaBancariaSelecionada() {
                if (estaNulo(this.contaBancariaSelecionada)){
                        setContaBancariaSelecionada(new ServidorContaBancaria());
                }
                return contaBancariaSelecionada;
        }
        public void setContaBancariaSelecionada(ServidorContaBancaria contaBancariaSelecionada) {
                this.contaBancariaSelecionada = contaBancariaSelecionada;
        }
       
        public ServidorDependente getDependenteSelecionado() {
                if (estaNulo(this.dependenteSelecionado)){
                        setDependenteSelecionado(new ServidorDependente());
                }
                return dependenteSelecionado;
        }
        public void setDependenteSelecionado(ServidorDependente dependenteSelecionado) {
                this.dependenteSelecionado = dependenteSelecionado;
        }
       
        public ServidorQualificacao getQualificacaoSelecionada() {
                if (estaNulo(this.qualificacaoSelecionada)){
                        setQualificacaoSelecionada(new ServidorQualificacao());
                }
                return qualificacaoSelecionada;
        }
        public void setQualificacaoSelecionada(ServidorQualificacao qualificacaoSelecionada) {
                this.qualificacaoSelecionada = qualificacaoSelecionada;
        }
       
        public Boolean getCadastrarDadoFuncional() {
                return cadastrarDadoFuncional;
        }
        public void setCadastrarDadoFuncional(Boolean cadastrarDadoFuncional) {
                this.cadastrarDadoFuncional = cadastrarDadoFuncional;
        }
       
        public void setCadastrarContaBancaria(Boolean cadastrarContaBancaria) {
                this.cadastrarContaBancaria = cadastrarContaBancaria;
        }
        public Boolean getCadastrarContaBancaria() {
                return cadastrarContaBancaria;
        }
       
        public Boolean getCadastrarDependente() {
                return cadastrarDependente;
        }
        public void setCadastrarDependente(Boolean cadastrarDependente) {
                this.cadastrarDependente = cadastrarDependente;
        }
       
        public Boolean getCadastrarQualificacao() {
                return cadastrarQualificacao;
        }
        public void setCadastrarQualificacao(Boolean cadastrarQualificacao) {
                this.cadastrarQualificacao = cadastrarQualificacao;
        }
       
        public ServidorLocalizacaoArquivo getServidorLocalizacaoArquivoSelecionado() {
                if(estaNulo(servidorLocalizacaoArquivoSelecionado)) {
                        servidorLocalizacaoArquivoSelecionado = estaNulo(getServidorSelecionado().getServidorLocalizacaoArquivo()) ?
                                        new ServidorLocalizacaoArquivo() : getServidorSelecionado().getServidorLocalizacaoArquivo();
                }
                return servidorLocalizacaoArquivoSelecionado;
        }

        public void setServidorLocalizacaoArquivoSelecionado(ServidorLocalizacaoArquivo servidorLocalizacaoArquivoSelecionado) {
                this.servidorLocalizacaoArquivoSelecionado = servidorLocalizacaoArquivoSelecionado;
        }
       
        public ServidorDadoFuncionalConselho getServidorDadoFuncionalConselho() {
                if(estaNulo(servidorDadoFuncionalConselho)) {
                        servidorDadoFuncionalConselho = new ServidorDadoFuncionalConselho();
                }
                return servidorDadoFuncionalConselho;
        }

        public void setServidorDadoFuncionalConselho(ServidorDadoFuncionalConselho servidorDadoFuncionalConselho) {
                this.servidorDadoFuncionalConselho = servidorDadoFuncionalConselho;
        }
       
        public String getTipoSituacaoCadastral() {
                return tipoSituacaoCadastral;
        }

        public void setTipoSituacaoCadastral(String tipoSituacaoCadastral) {
                this.tipoSituacaoCadastral = tipoSituacaoCadastral;
        }
       
        public List<ModelCampoCombo> getListaTipoSituacaoCadastral() {
                listaTipoSituacaoCadastral = new ArrayList<ModelCampoCombo>();
               
                if(isUsuarioConectadoTecnicoSIF()) {
                        listaTipoSituacaoCadastral.add(new ModelCampoCombo(TipoSituacaoCadastral.VALIDADO.getDescricao(), TipoSituacaoCadastral.VALIDADO.getValue()));
                        listaTipoSituacaoCadastral.add(new ModelCampoCombo(TipoSituacaoCadastral.HOMOLOGADO.getDescricao(), TipoSituacaoCadastral.HOMOLOGADO.getValue()));
                } else {
                        listaTipoSituacaoCadastral.add(new ModelCampoCombo(TipoSituacaoCadastral.VALIDADO.getDescricao(), TipoSituacaoCadastral.VALIDADO.getValue()));
                }
               
                return listaTipoSituacaoCadastral;
        }

        public void setListaTipoSituacaoCadastral(List<ModelCampoCombo> listaTipoSituacaoCadastral) {
                this.listaTipoSituacaoCadastral = listaTipoSituacaoCadastral;
        }
       
        public List<TipoVinculo> getListaTiposVinculo() {
                if(estaNulo(listaTiposVinculo)) {
                        listaTiposVinculo = gerarListaTiposVinculosParaDadoFuncional();
                }
                return listaTiposVinculo;
        }

        public void setListaTiposVinculo(List<TipoVinculo> listaTiposVinculo) {
                this.listaTiposVinculo = listaTiposVinculo;
        }
       
        public TipoVinculo getTipoVinculoSelecionado() {
                return tipoVinculoSelecionado;
        }

        public void setTipoVinculoSelecionado(TipoVinculo tipoVinculoSelecionado) {
                this.tipoVinculoSelecionado = tipoVinculoSelecionado;
        }

        public List<FormaIngresso> getListaFormasIngresso() {
                listaFormasIngresso = formaIngressoFacade.listarFormaIngressoParaDadoFuncional(getServidorSelecionado().getSituacaoCadastral(), getUsuarioLogado(), getTipoVinculoSelecionado());
                return listaFormasIngresso;
        }

        public void setListaFormasIngresso(List<FormaIngresso> listaFormasIngresso) {
                this.listaFormasIngresso = listaFormasIngresso;
        }

        public FormaIngresso getFormaIngressoSelecionada() {
                return formaIngressoSelecionada;
        }

        public void setFormaIngressoSelecionada(FormaIngresso formaIngressoSelecionada) {
                this.formaIngressoSelecionada = formaIngressoSelecionada;
        }

        public List<Unidade> getListaUnidadesAtivas() {
                if(estaNulo(listaUnidadesAtivas)) {
                        listaUnidadesAtivas = new ArrayList<Unidade>();
                }
                if(naoEstaNulo(getDadoFuncionalSelecionado().getOrgaoLotacao())) {
                        Unidade unidade = new Unidade();
                        unidade.setOrgao(getDadoFuncionalSelecionado().getOrgaoLotacao());
                        listaUnidadesAtivas = unidadeFacade.listarUnidadeAtiva(unidade);
                }
                return listaUnidadesAtivas;
        }

        public void setListaUnidadesAtivas(List<Unidade> listaUnidadesAtivas) {
                this.listaUnidadesAtivas = listaUnidadesAtivas;
        }
       
        public Funcao getFuncaoConsulta() {
                if(estaNulo(funcaoConsulta)) {
                        funcaoConsulta = new Funcao();
                }
                return funcaoConsulta;
        }

        public void setFuncaoConsulta(Funcao funcaoConsulta) {
                this.funcaoConsulta = funcaoConsulta;
        }
       
        public Cargo getCargoConsulta() {
                if(estaNulo(cargoConsulta)) {
                        cargoConsulta = new Cargo();
                }
                return cargoConsulta;
        }

        public void setCargoConsulta(Cargo cargoConsulta) {
                this.cargoConsulta = cargoConsulta;
        }
       
        public List<InstituicaoEstagio> getListaInstituicaoEstagio() {
                return listaInstituicaoEstagio;
        }

        public void setListaInstituicaoEstagio(List<InstituicaoEstagio> listaInstituicaoEstagio) {
                this.listaInstituicaoEstagio = listaInstituicaoEstagio;
        }
       
        public List<CursoEstagio> getListaCursoEstagio() {
                return listaCursoEstagio;
        }

        public void setListaCursoEstagio(List<CursoEstagio> listaCursoEstagio) {
                this.listaCursoEstagio = listaCursoEstagio;
        }
       
        public List<ModelCampoCombo> getListaNivelEstagio() {
                listaNivelEstagio = new ArrayList<ModelCampoCombo>();
               
                for (TipoNivelEstagio nivel : TipoNivelEstagio.values()) {  
                        listaNivelEstagio.add(new ModelCampoCombo(nivel.toString(), nivel.getValue()));
                }

                return listaNivelEstagio;
        }

        public void setListaNivelEstagio(List<ModelCampoCombo> listaNivelEstagio) {
                this.listaNivelEstagio = listaNivelEstagio;
        }
       
        public List<ModelCampoCombo> getListaCargaHoraria() {
                listaCargaHoraria = new ArrayList<ModelCampoCombo>();
               
                if(getFormaIngressoSelecionada().getCodigo().equals(FORMA_INGRESSO_ESTAGIARIO)) {
                        listaCargaHoraria.add(new ModelCampoCombo("20", 20));
                        listaCargaHoraria.add(new ModelCampoCombo("30", 30));
                        listaCargaHoraria.add(new ModelCampoCombo("60", 60));
                } else {
                        listaCargaHoraria.add(new ModelCampoCombo("20", 20));
                        listaCargaHoraria.add(new ModelCampoCombo("24", 24));
                        listaCargaHoraria.add(new ModelCampoCombo("30", 30));
                        listaCargaHoraria.add(new ModelCampoCombo("40", 40));
                }

                return listaCargaHoraria;
        }

        public void setListaCargaHoraria(List<ModelCampoCombo> listaCargaHoraria) {
                this.listaCargaHoraria = listaCargaHoraria;
        }
       
        public UploadedFile getFotoUpload() {
                return fotoUpload;
        }

        public void setFotoUpload(UploadedFile fotoUpload) {
                this.fotoUpload = fotoUpload;
        }

        public CroppedImage getFotoRecortada() {
                return fotoRecortada;
        }

        public void setFotoRecortada(CroppedImage fotoRecortada) {
                this.fotoRecortada = fotoRecortada;
        }
       
        public String getNomeArquivoFoto() {
                return nomeArquivoFoto;
        }

        public void setNomeArquivoFoto(String nomeArquivoFoto) {
                this.nomeArquivoFoto = nomeArquivoFoto;
        }

        public void handleFileUpload(final FileUploadEvent event) throws IOException {
                setFotoUpload(event.getFile());
                salvarArquivoFotoUpload();
        }

        private void apagarArquivosFotosDoServidor() {
                File pastaFotos = new File(getCaminhoPastaFotosUploadTemporarias());
                FileFilter fileFilter = new WildcardFileFilter(getIdentificadorServidorCodificado() + "_*.*");
                File[] fotos = pastaFotos.listFiles(fileFilter);
                for(int i = 0; i < fotos.length; i++) {
                        fotos[i].delete();
                }
        }
       
        private void salvarArquivoFotoUpload() {
                apagarArquivosFotosDoServidor();
                gerarNomeArquivoFoto();
                salvarArquivoFoto(getFotoUpload().getContents());
        }

        public void recortarFoto() throws IOException {
                if(naoEstaNulo(getFotoRecortada())) {
                        getServidorSelecionado().setFoto(getFotoRecortada().getBytes());
                        salvarArquivoFotoRecortada();
                        setFotoUpload(null);
                }
        }
       
        private void salvarArquivoFotoRecortada() {
                apagarArquivosFotosDoServidor();
                gerarNomeArquivoFoto();
                salvarArquivoFoto(getFotoRecortada().getBytes());
        }

        private String getCaminhoCompletoFotoUpload() {
                return getCaminhoPastaFotosUploadTemporarias() + getNomeArquivoFoto();
        }
       
        private String getCaminhoPastaFotosUploadTemporarias() {
                ServletContext servletContext = (ServletContext) FacesContext.getCurrentInstance().getExternalContext().getContext();
        return servletContext.getRealPath("") + File.separator + "paginas" + File.separator + "fotos_temp" + File.separator;
        }
       
        private void gerarNomeArquivoFoto() {
                String identificadorServidor = getIdentificadorServidorCodificado();
                String timestamp = new Long(new Date().getTime()).toString();
                String extensao = naoEstaNulo(getFotoUpload()) ? FilenameUtils.getExtension(getFotoUpload().getFileName()) : "jpg";
                setNomeArquivoFoto(identificadorServidor + "_" + timestamp + "." + extensao);
        }
       
        private String getIdentificadorServidorCodificado() {
                String identificadorServidor = getServidorSelecionado().getSequencialDaPessoa().toString();
                return DigestUtils.md5DigestAsHex(identificadorServidor.getBytes());
        }
       
        private void salvarArquivoFotoBanco() {
                if(naoEstaNulo(servidorSelecionado) && naoEstaNuloOuVazio(servidorSelecionado.getFoto())) {
                        apagarArquivosFotosDoServidor();
                        gerarNomeArquivoFoto();
                        salvarArquivoFoto(getServidorSelecionado().getFoto());
                }
        }
       
        private void salvarArquivoFoto(byte[] conteudo) {
                try {
                        FileImageOutputStream imagem = new FileImageOutputStream(new File(getCaminhoCompletoFotoUpload()));
                        imagem.write(conteudo, 0, conteudo.length);
                        imagem.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

        public Servidor getServidorSelecionado() {
                if (estaNulo(servidorSelecionado) && getConsultarServidor()) {
                        servidorSelecionado = servidorFacade.consultarServidorPorSequencial(getSequencialPessoaUsuarioLogado());
                        if (estaNulo(servidorSelecionado)) {
                                setServidorSelecionado(new Servidor());
                                getServidorSelecionado().setPessoa(servidorFacade.consultarPessoaPorSequencial(getSequencialPessoaUsuarioLogado()));
                        }
                        salvarArquivoFotoBanco();
                }
                return servidorSelecionado;
        }

        public void setServidorSelecionado(Servidor servidorSelecionado) {
                this.servidorSelecionado = servidorSelecionado;
        }
       
        public void adicionarDadoFuncionalAhEntidade() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                preencherCamposDadoFuncional();
                                validarObjeto(getDadoFuncionalSelecionado());
                                getListaDadosFuncionais().add(getDadoFuncionalSelecionado());
                                limparEntidadeDadoFuncional();
                        }
                });
        }
               
        public void alterarDadoFuncional() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                preencherCamposDadoFuncional();
                                validarObjeto(getDadoFuncionalSelecionado());
                                getListaDadosFuncionais().set(getListaDadosFuncionais().indexOf(getDadoFuncionalSelecionado()), getDadoFuncionalSelecionado());
                                limparEntidadeDadoFuncional();
                        }
                });
        }
       
        private void preencherCamposDadoFuncional() {
                getDadoFuncionalSelecionado().setFormaIngresso(getFormaIngressoSelecionada());
                getDadoFuncionalSelecionado().setServidor(getServidorSelecionado());
                atribuirServidorDadoFuncionalConselhoCasoTenhaSidoPreenchido();
        }

        private void atribuirServidorDadoFuncionalConselhoCasoTenhaSidoPreenchido() {
                if(servidorDadoFuncionalConselhoFoiPreenchido()) {
                        getDadoFuncionalSelecionado().setServidorDadoFuncionalConselho(getServidorDadoFuncionalConselho());
                        getServidorDadoFuncionalConselho().setServidorDadoFuncional(getDadoFuncionalSelecionado());
                } else {
                        getDadoFuncionalSelecionado().setServidorDadoFuncionalConselho(null);
                }
        }

        private Boolean servidorDadoFuncionalConselhoFoiPreenchido() {
                return naoEstaNuloOuVazio(getServidorDadoFuncionalConselho().getNumeroInscricaoConselho())
                                || naoEstaNuloOuVazio(getServidorDadoFuncionalConselho().getConselho())
                                || naoEstaNuloOuVazio(getServidorDadoFuncionalConselho().getUf());
        }
       
        public void limparEntidadeDadoFuncional() {
                limparDadosFuncionais();
                limparDadosConsultaFuncao();
                setCadastrarDadoFuncional(true);
        }

        public void adicionarContaBancariaAhEntidade() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                adicionarReferenciasNaEntidadeContaBancaria();
                                validarObjeto(getContaBancariaSelecionada());
                                getListaContasBancarias().add(getContaBancariaSelecionada());
                                limparEntidadeContaBancaria();
                        }
                });
        }
       
        public void alterarContaBancaria() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                adicionarReferenciasNaEntidadeContaBancaria();
                                validarObjeto(getContaBancariaSelecionada());
                                getListaContasBancarias().set(getListaContasBancarias().indexOf(getContaBancariaSelecionada()), getContaBancariaSelecionada());
                                limparEntidadeContaBancaria();
                        }
                });
        }

        private void adicionarReferenciasNaEntidadeContaBancaria() {
                ServidorContaBancarialId servidorContaBancarialId = new ServidorContaBancarialId();
                servidorContaBancarialId.setSequencialPessoaServidor(getServidorSelecionado().getSequencialDaPessoa());
                getContaBancariaSelecionada().setServidorContaBancarialId(servidorContaBancarialId);
                getContaBancariaSelecionada().setServidor(getServidorSelecionado());
                getContaBancariaSelecionada().getServidorContaBancarialId().setCodigoBanco(getContaBancariaSelecionada().getBanco().getCodigo());
        }
       
        public void limparEntidadeContaBancaria() {
                setContaBancariaSelecionada(new ServidorContaBancaria());
                setCadastrarContaBancaria(true);
        }
       
        public void adicionarDependenteAhEntidade() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                removerFormatacaoCpfDependente(getDependenteSelecionado());
                                adicionarReferenciasNaEntidadeDependente();
                                validarObjeto(getDependenteSelecionado());
                                getListaDependentes().add(getDependenteSelecionado());
                                limparEntidadeDependente();
                        }
                });
        }
       
        public void alterarDependente() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                removerFormatacaoCpfDependente(getDependenteSelecionado());
                                adicionarReferenciasNaEntidadeDependente();
                                validarObjeto(getDependenteSelecionado());
                                getListaDependentes().set(getListaDependentes().indexOf(getDependenteSelecionado()), getDependenteSelecionado());
                                limparEntidadeDependente();
                        }
                });
        }
       
        private void removerFormatacaoCpfDependente(ServidorDependente dependente) {
                if(naoEstaNuloOuVazio(dependente.getNumeroCpf())) {
                        dependente.setNumeroCpf(StringUtils.removerDaStringFormatacoesInformadas(dependente.getNumeroCpf(), StringUtils.FORMATACAO_PONTO, StringUtils.FORMATACAO_HIFEN));
                }
        }
       
        private void adicionarReferenciasNaEntidadeDependente() {
                getDependenteSelecionado().setServidor(getServidorSelecionado());
        }
       
        public void limparEntidadeDependente() {
                setDependenteSelecionado(new ServidorDependente());
                setCadastrarDependente(true);
        }
       
        public void adicionarQualificacaoAhEntidade() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                adicionarReferenciasNaEntidadeQualificacao();
                                validarObjeto(getQualificacaoSelecionada());
                                getListaQualificacoes().add(getQualificacaoSelecionada());
                                limparEntidadeQualificacao();
                        }
                });
        }
       
        public void alterarQualificacao() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                adicionarReferenciasNaEntidadeQualificacao();
                                validarObjeto(getQualificacaoSelecionada());
                                getListaQualificacoes().set(getListaQualificacoes().indexOf(getQualificacaoSelecionada()), getQualificacaoSelecionada());
                                limparEntidadeQualificacao();
                        }
                });
        }
       
        private void adicionarReferenciasNaEntidadeQualificacao() {
                getQualificacaoSelecionada().setServidor(getServidorSelecionado());
        }
       
        public void limparEntidadeQualificacao() {
                setQualificacaoSelecionada(new ServidorQualificacao());
                setCadastrarQualificacao(true);
        }
       
        private UsuarioView getUsuarioLogado() {
                return ((UsuarioView) getUsuario().getPrincipal());
        }
       
        private Long getSequencialPessoaUsuarioLogado() {
                return ((UsuarioView) getUsuario().getPrincipal()).getSequencialPessoa();
        }

        public void setarEntidadeDadosFuncionais(ServidorDadoFuncional dadoFuncional) {
                limparDadosFuncionais();
               
                if(dadoFuncional instanceof ServidorDadoFuncionalMatriculaCarreira) {
                        dadoFuncionalMatriculaCarreira = (ServidorDadoFuncionalMatriculaCarreira) dadoFuncional;
                }
                if(dadoFuncional instanceof ServidorDadoFuncionalMatricula && dadoFuncionalMatriculaCarreira == null) {
                        dadoFuncionalMatricula = (ServidorDadoFuncionalMatricula) dadoFuncional;
                }
                if(dadoFuncional instanceof ServidorDadoFuncionalContratadoEstagiario) {
                        dadoFuncionalContratadoEstagiario = (ServidorDadoFuncionalContratadoEstagiario) dadoFuncional;
                }
                if(dadoFuncional instanceof ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo) {
                        dadoFuncionalContratadoPrestadorProcessoSeletivo = (ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo) dadoFuncional;
                }
                setDadoFuncionalSelecionado(dadoFuncional);
                setFormaIngressoSelecionada(dadoFuncional.getFormaIngresso());
                setTipoVinculoSelecionado(TipoVinculo.parse(getFormaIngressoSelecionada().getTipoVinculo()));
                setarDadoFuncionalConselho(getDadoFuncionalSelecionado());
                setCadastrarDadoFuncional(false);
        }
       
        public void setarEntidadeDadosFuncionaisDetalhar(ServidorDadoFuncional dadoFuncional) {
                limparDadosFuncionais();
               
                if(dadoFuncional instanceof ServidorDadoFuncionalMatriculaCarreira) {
                        dadoFuncionalMatriculaCarreiraDetalhar = (ServidorDadoFuncionalMatriculaCarreira) dadoFuncional;
                }
                if(dadoFuncional instanceof ServidorDadoFuncionalMatricula && dadoFuncionalMatriculaCarreiraDetalhar == null) {
                        dadoFuncionalMatriculaDetalhar = (ServidorDadoFuncionalMatricula) dadoFuncional;
                }
                if(dadoFuncional instanceof ServidorDadoFuncionalContratadoEstagiario) {
                        dadoFuncionalContratadoEstagiarioDetalhar = (ServidorDadoFuncionalContratadoEstagiario) dadoFuncional;
                }
                if(dadoFuncional instanceof ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo) {
                        dadoFuncionalContratadoPrestadorProcessoSeletivoDetalhar = (ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo) dadoFuncional;
                }
                setDadoFuncionalSelecionadoDetalhar(dadoFuncional);
                setCadastrarDadoFuncional(false);
        }
       
        private void setarDadoFuncionalConselho(ServidorDadoFuncional dadoFuncional) {
                servidorDadoFuncionalConselho = estaNulo(dadoFuncional.getServidorDadoFuncionalConselho()) ?
                        new ServidorDadoFuncionalConselho() : dadoFuncional.getServidorDadoFuncionalConselho();
        }

        public void setarEntidadeContasBancarias(ServidorContaBancaria contaBancaria) {
                setContaBancariaSelecionada(contaBancaria);
                setCadastrarContaBancaria(false);
        }
       
        public void setarEntidadeDependentes(ServidorDependente servidorDependente) {
                setDependenteSelecionado(servidorDependente);
                setCadastrarDependente(false);
        }
       
        public void setarEntidadeQualificacoes(ServidorQualificacao servidorQualificacao) {
                setQualificacaoSelecionada(servidorQualificacao);
                setCadastrarQualificacao(false);
        }
       
        public void removerDadoFuncionalDaLista(final ServidorDadoFuncional dadoFuncional) {
                if (getListaDadosFuncionais().contains(dadoFuncional)) {
                        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                                public void execute() {
                                        getListaDadosFuncionais().remove(dadoFuncional);
                                        limparEntidadeDadoFuncional();
                                }
                        });
                }
        }
       
        public void removerContaBancariaDaLista(final ServidorContaBancaria contaBancaria) {
                if (getListaContasBancarias().contains(contaBancaria)) {
                        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                                public void execute() {
                                        getListaContasBancarias().remove(contaBancaria);
                                        limparEntidadeContaBancaria();
                                }
                        });
                }
        }
       
        public void removerDependenteDaLista(final ServidorDependente servidorDependente) {
                if (getListaDependentes().contains(servidorDependente)) {
                        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                                public void execute() {
                                        getListaDependentes().remove(servidorDependente);
                                        limparEntidadeDependente();
                                }
                        });
                }
        }
       
        public void removerQualificacaoDaLista(final ServidorQualificacao servidorQualificacao) {
                if (getListaQualificacoes().contains(servidorQualificacao)) {
                        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                                public void execute() {
                                        getListaQualificacoes().remove(servidorQualificacao);
                                        limparEntidadeQualificacao();
                                }
                        });
                }
        }
       
        public ParametroConsultaServidorDTO getParametro() {
                if (estaNulo(parametro)) {
                        parametro = new ParametroConsultaServidorDTO();
                }
                return parametro;
        }

        public void setParametro(ParametroConsultaServidorDTO parametro) {
                this.parametro = parametro;
        }

        public void prepararRestricoesParaConsulta() {
                this.lazy.setParametro(getParametro());
        }
       
        public void prepararRestricoesParaConsultaFuncao() {
                lazyFuncaoDTO.setParametros(getParametrosConsultaFuncaoDTO());
        }
       
        public void prepararRestricoesParaConsultaCargo() {
                lazyCargoDTO.setParametros(getParametrosConsultaCargoDTO());
        }
       
        public Boolean getCadastrarPessoa() {
                return cadastrarPessoa;
        }
        public void setCadastrarPessoa(Boolean cadastrarPessoa) {
                this.cadastrarPessoa = cadastrarPessoa;
        }
       
        public Boolean getServidorDados() {
                return servidorDados;
        }
        public void setServidorDados(Boolean servidorDados) {
                this.servidorDados = servidorDados;
        }
       
        public Boolean getConsultarServidor() {
                return consultarServidor;
        }

        public void setConsultarServidor(Boolean consultarServidor) {
                this.consultarServidor = consultarServidor;
        }
       
        public void desabilitarConsultarServidor() {
                if(!consultaDesabilitada) {
                        setConsultarServidor(false);
                        consultaDesabilitada = true;
                }
        }
       
        public Date getDataAtual() {
                return new Date();
        }
       
        public void prepararParaCadastrarPessoa(){
                setCadastrarPessoa(true);
                setServidorDados(true);
                setConsultarServidor(true);
        }

        @Override
        public void setarPessoa(final PessoaDTO pessoaDTO) {
                setCadastrarPessoa(false);
               
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        @Override
                        public void execute() {
                                PessoaFisicaView pessoaFisicaView = new PessoaFisicaView();
                                pessoaFisicaView.setSequencialPessoa(pessoaDTO.getId());
                               
                                ServidorDTO servidorDTO = new ServidorDTO();
                                servidorDTO.setSequencialPessoa(pessoaFisicaView.getSequencialPessoa());
                                preparaServidorParaAtualizarDados(servidorDTO);
                               
                                if (estaNulo(servidorSelecionado)) {
                                        Servidor servidor = new Servidor();
                                        PessoaFisicaView pessoaConsultada = ((ServidorFacade)getFacade()).consultarPessoaPorSequencial((Long)pessoaDTO.getId());
                                        servidor.setPessoa(pessoaConsultada);
                                        UsuarioView usuario = new UsuarioView();
                                        usuario.setSequencialPessoa(getSequencialPessoaUsuarioLogado());
                                        servidor.setUsuario(usuario);
                                        setServidorSelecionado(servidor);
                                }
                               
                                iniciarListas();
                        }
                });
        }
       
        @Override
        protected void popularObjetoSeIdPessoaDiferenteDeNulo(String idPessoaCadastrada) {
                if (naoEstaNuloOuVazio(idPessoaCadastrada)) {
                  if(!idPessoaCadastrada.equals("0")){
                          PessoaDTO pessoaDTO = new PessoaDTO();
                          pessoaDTO.setId(Long.valueOf(idPessoaCadastrada));
                          setarPessoa(pessoaDTO);
                          setServidorDados(true);
                          setConsultarServidor(true);
                  }
                }
        }
       
        @Override
        public void alterar(final Servidor servidor) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                modificarEntidadeAntesDaOperacao();
                                ((ServidorFacade)getFacade()).atualizarServidor(servidor);
                                ((ServidorFacade)getFacade()).atualizarServidorLegado(servidor);
                                limparEntidade();
                                salvarArquivoFotoBanco();
                                LancadorMensagem.lancarSucesso(getMensagens().get(IDENTIFICADOR_MENSAGEM_ALTERADO_COM_SUCESSO));
                        }
                });
        }
       
        public void alterarServidor(final Servidor servidor) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                modificarEntidadeAntesDaOperacao();
                                ((ServidorFacade)getFacade()).atualizarServidor(servidor);
                                ((ServidorFacade)getFacade()).atualizarServidorLegado(servidor);
                                limparEntidade();
                                salvarArquivoFotoBanco();
                                LancadorMensagem.lancarSucesso(getMensagens().get(IDENTIFICADOR_MENSAGEM_ALTERADO_COM_SUCESSO));
                        }
                });
        }

        public void alterarSituacaoCadastral(final Servidor servidor) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                modificarEntidadeAntesDaOperacao();
                                ((ServidorFacade)getFacade()).atualizarServidor(servidor);
                                setarUsuarioAlteracaoSituacaoCadastral(servidor);
                                ((ServidorFacade)getFacade()).alterarSituacaoFichaCadastral(servidor, TipoSituacaoCadastral.parse(tipoSituacaoCadastral));
                                ((ServidorFacade)getFacade()).atualizarServidorLegado(servidor);
                                limparEntidade();
                                salvarArquivoFotoBanco();
                                LancadorMensagem.lancarSucesso(getMensagens().get(IDENTIFICADOR_MENSAGEM_ALTERADO_COM_SUCESSO));
                        }
                });
        }

        public TipoSituacaoCadastral[] getTiposSitucoesCadastrais() {
                return TipoSituacaoCadastral.values();
        }
       
        public String descricaoSituacaoServidor(ServidorDadoFuncional servidorDadoFuncional) {
                if(servidorDadoFuncional instanceof ServidorDadoFuncionalMatricula) {
                        return getSituacaoServidorDadoFuncionalMatricula((ServidorDadoFuncionalMatricula)servidorDadoFuncional);
                }
                if(servidorDadoFuncional instanceof ServidorDadoFuncionalContratado) {
                        return getSituacaoServidorDadoFuncionalContratado((ServidorDadoFuncionalContratado)servidorDadoFuncional);
                }
                return null;
        }
       
        private <T extends ServidorDadoFuncionalMatricula> String getSituacaoServidorDadoFuncionalMatricula(T dadoFuncional) {
                return ((ServidorDadoFuncionalMatricula)dadoFuncional).getSituacaoServidor().getDescricao();
        }
       
        private <T extends ServidorDadoFuncionalContratado> String getSituacaoServidorDadoFuncionalContratado(T dadoFuncional) {
                return dadoFuncional.getDescricaoSituacaoServidor();
        }
       
        private List<TipoVinculo> gerarListaTiposVinculosParaDadoFuncional() {
                List<TipoVinculo> lista = new ArrayList<TipoVinculo>();

                if(isSituacaoFichaCadastralHomologadoOuValidado() && (isUsuarioConectadoTecnicoSAFP() || isUsuarioConectadoTecnicoSER())) {
                        lista.add(TipoVinculo.CONTRATADO);
                } else {
                        lista.add(TipoVinculo.EFETIVO);
                        lista.add(TipoVinculo.COMISSIONADO);
                        lista.add(TipoVinculo.CONTRATADO);
                        lista.add(TipoVinculo.CELETISTA);
                }
               
                return lista;
        }
       
        public Boolean temPermissaoAlterarDadosGerais() {
                if(isSituacaoFichaCadastralHomologadoOuValidado()) {
                        if(isUsuarioConectadoServidor() ||
                           isUsuarioConectadoTecnicoSAFP() ||
                           isUsuarioConectadoTecnicoSER() ||
                           isUsuarioConectadoTecnicoSAD() ||
                           isUsuarioConectadoTecnicoSCGDP()
                           ) {
                                return false;
                        }
                }
                return true;
        }
       
        public Boolean temPermissaoEspecialAlterarDadoFuncional(ServidorDadoFuncional dadoFuncional) {
                if(isSituacaoFichaCadastralHomologadoOuValidado() && naoEstaNulo(dadoFuncional)) {
                        if(isUsuarioConectadoTecnicoSAFP() && dadoFuncional.getFormaIngresso().getCodigo().equals(FORMA_INGRESSO_PRESTADOR)) {
                                return true;
                        }
                        if(isUsuarioConectadoTecnicoSER() && dadoFuncional.getFormaIngresso().getCodigo().equals(FORMA_INGRESSO_ESTAGIARIO)) {
                                return true;
                        }
                }
                return false;
        }
       
        public Boolean temPermissaoEspecialAlterarDadoBancario() {
                if(isSituacaoFichaCadastralHomologadoOuValidado() && isUsuarioConectadoTecnicoSAFP()) {
                        return true;
                }
                return false;
        }
       
        public Boolean temPermissaoEspecialAlterarQualificacao() {
                if(isUsuarioConectadoTecnicoSAD()) {
                        return true;
                }
                return false;
        }
       
        private Boolean isSituacaoFichaCadastralHomologadoOuValidado() {
                return getServidorSelecionado().getSituacaoCadastral().equals(TipoSituacaoCadastral.HOMOLOGADO)
                                || getServidorSelecionado().getSituacaoCadastral().equals(TipoSituacaoCadastral.VALIDADO);
        }
       
        private Boolean isUsuarioConectadoServidor() {
                return verificarPermissao(PAPEL_SERVIDOR) && !verificarPermissao(PAPEL_SERVIDOR_TECNICO_SIF);
        }
       
        private Boolean isUsuarioConectadoTecnicoSAFP() {
                return verificarPermissao(PAPEL_SERVIDOR_TECNICO_SAFP) && !verificarPermissao(PAPEL_SERVIDOR_TECNICO_SIF);
        }
       
        private Boolean isUsuarioConectadoTecnicoSER() {
                return verificarPermissao(PAPEL_SERVIDOR_TECNICO_SER) && !verificarPermissao(PAPEL_SERVIDOR_TECNICO_SIF);
        }
       
        private Boolean isUsuarioConectadoTecnicoSAD() {
                return verificarPermissao(PAPEL_SERVIDOR_TECNICO_SAD) && !verificarPermissao(PAPEL_SERVIDOR_TECNICO_SIF);
        }
       
        private Boolean isUsuarioConectadoTecnicoSCGDP() {
                return verificarPermissao(PAPEL_SERVIDOR_TECNICO_CSGDP) && !verificarPermissao(PAPEL_SERVIDOR_TECNICO_SIF);
        }
       
        private Boolean isUsuarioConectadoTecnicoSIF() {
                return verificarPermissao(PAPEL_SERVIDOR_TECNICO_SIF);
        }

        public StreamedContent emitirFichaCadastral(final Long sequencialPessoa) throws Exception {
                return new RelatorioVerificadorLancamentoException().verificarLancamentoException(new CommandRelatorio() {
                        private JasperPrint relatorio;
                       
                        @Override
                        public StreamedContent execute() throws Exception {
                                relatorio = servidorFacade.emitirFichaCadastral(sequencialPessoa);
                                return gerarPdf(relatorio, "Ficha Cadastral");
                        }
                });
        }
       
        private class RelatorioVerificadorLancamentoException {
                public RelatorioVerificadorLancamentoException() {}

                public StreamedContent verificarLancamentoException(CommandRelatorio commandRelatorio) {
                        try {
                                return commandRelatorio.execute();
                        } catch (RuntimeException e) {
                                LancadorMensagem.lancarAlerta(e.getMessage());
                        } catch (Exception e) {
                                LancadorMensagem.lancarErro(e.getMessage());
                        }
                        return null;
                }
        }
       
        private interface CommandRelatorio {
                StreamedContent execute() throws RelatorioException, Exception;
        }
       
        protected StreamedContent gerarPdf(JasperPrint relatorio, String nomeRelatorio) throws Exception {
                byte[] arquivo = null;
                arquivo = JasperExportManager.exportReportToPdf(relatorio);
                String nomeDoArquivo = nomeRelatorio + ".pdf";
                OutputStream out = new ByteArrayOutputStream();
                out.write(arquivo);
                ByteArrayInputStream input = new ByteArrayInputStream(((ByteArrayOutputStream)out).toByteArray());
                return new DefaultStreamedContent(input, "application/pdf", nomeDoArquivo);
        }
       
        private void setarUsuarioAlteracaoSituacaoCadastral(final Servidor servidor) {
                UsuarioView usuarioHomologacao = new UsuarioView();
                usuarioHomologacao.setSequencialPessoa(getSequencialPessoaUsuarioLogado());
                servidor.setUsuarioAlteracaoSituacaoCadastral(usuarioHomologacao);
        }
       
        public void preparaServidorParaAtualizarDados(ServidorDTO servidor) {
                setServidorSelecionado(((ServidorFacade)getFacade()).consultarServidorPorSequencial(servidor.getSequencialPessoa()));
                limparListasServidor();
                setServidorDados(true);
                setConsultarServidor(true);
                salvarArquivoFotoBanco();
        }
       
        private void limparListasServidor() {
                setListaDocumento(null);
                setListaDadosFuncionais(null);
                setListaContasBancarios(null);
                setListaDependentes(null);
                setListaQualificacoes(null);
        }
       
        public void limparDadosFuncionais() {
                dadoFuncionalSelecionado = null;
                dadoFuncionalMatricula = null;
                dadoFuncionalMatriculaCarreira = null;
                dadoFuncionalContratadoEstagiario = null;
                dadoFuncionalContratadoPrestadorProcessoSeletivo = null;
                dadoFuncionalMatriculaDetalhar = null;
                dadoFuncionalMatriculaCarreiraDetalhar = null;
                dadoFuncionalContratadoEstagiarioDetalhar = null;
                dadoFuncionalContratadoPrestadorProcessoSeletivoDetalhar = null;
                formaIngressoSelecionada = null;
                servidorDadoFuncionalConselho = null;
        }
       
        public void limparDadosConsultaFuncao() {
                funcaoConsulta = new Funcao();
                lazyFuncaoDTO.habilitarConsulta();
                prepararRestricoesParaConsultaFuncao();
        }
       
        public void limparDadosConsultaCargo() {
                cargoConsulta = new Cargo();
                lazyCargoDTO.habilitarConsulta();
                prepararRestricoesParaConsultaCargo();
        }
       
        public void limparDadosConsultaServidor() {
                limparListasServidor();
                setServidorDados(false);
                setConsultarServidor(false);
                setFotoUpload(null);
                setFotoRecortada(null);
        }
       
        public void setarFuncaoDadoFuncional(FuncaoDTO funcaoDTO) {
                Funcao funcao = new Funcao();
                funcao.setCodigo(funcaoDTO.getCodigo());
                if(getDadoFuncionalSelecionado() instanceof ServidorDadoFuncionalMatricula) {
                        ((ServidorDadoFuncionalMatricula)getDadoFuncionalSelecionado()).setFuncao(funcaoFacade.consultarPorId(funcao));
                }
        }

        public void setarCargoDadoFuncional(CargoDTO cargoDTO) {
                Cargo cargo = new Cargo();
                cargo.setCodigo(cargoDTO.getCodigo());
                if(getDadoFuncionalSelecionado() instanceof ServidorDadoFuncionalMatriculaCarreira) {
                        ((ServidorDadoFuncionalMatriculaCarreira)getDadoFuncionalSelecionado()).setCargoCarreira(cargoFacade.consultarPorId(cargo));
                }
                if(getDadoFuncionalSelecionado() instanceof ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo) {
                        ((ServidorDadoFuncionalContratadoPrestadorProcessoSeletivo)getDadoFuncionalSelecionado()).setCargo(cargoFacade.consultarPorId(cargo));
                }
        }
       
        private ParametroConsultaFuncaoDTO getParametrosConsultaFuncaoDTO() {
                ParametroConsultaFuncaoDTO parametros = new ParametroConsultaFuncaoDTO();

                if(naoEstaNuloOuVazio(getFuncaoConsulta().getDescricao())) {
                        parametros.setDescricao(getFuncaoConsulta().getDescricao());
                }
               
                if(naoEstaNuloOuVazio(getFuncaoConsulta().getNivel())) {
                        parametros.setNivel(getFuncaoConsulta().getNivel());
                }
               
                if(naoEstaNuloOuVazio(getFuncaoConsulta().getTipo())) {
                        parametros.setTipo(getFuncaoConsulta().getTipoFuncao());
                }

                return parametros;
        }
       
        private ParametroConsultaCargoDTO getParametrosConsultaCargoDTO() {
                ParametroConsultaCargoDTO parametros = new ParametroConsultaCargoDTO();

                if(naoEstaNuloOuVazio(getCargoConsulta().getDescricao())) {
                        parametros.setDescricao(getCargoConsulta().getDescricao());
                }

                if(naoEstaNuloOuVazio(getCargoConsulta().getGrauInstrucao())) {
                        parametros.setGrauInstrucao(getCargoConsulta().getGrauInstrucao());
                }

                return parametros;
        }

        private void validarObjeto(Object entidade) {
                validador.validar(entidade, Cadastrar.class);
        }
       
        /* antigo Ficha Cadastral Bean */
        public List<GrauInstrucao> getListaGrauInstrucao() {
                return listaGrauInstrucao;
        }

        public void setListaGrauInstrucao(List<GrauInstrucao> listaGrauInstrucao) {
                this.listaGrauInstrucao = listaGrauInstrucao;
        }

        public List<Nacionalidade> getListaNacionalidade() {
                return listaNacionalidade;
        }

        public void setListaNacionalidade(List<Nacionalidade> listaNacionalidade) {
                this.listaNacionalidade = listaNacionalidade;
        }

        public List<Deficiencia> getListaDeficiencia() {
                return listaDeficiencia;
        }

        public void setListaDeficiencia(List<Deficiencia> listaDeficiencia) {
                this.listaDeficiencia = listaDeficiencia;
        }

        public List<SituacaoServidor> getListaSituacaoServidor() {
                return listaSituacaoServidor;
        }

        public void setListaSituacaoServidor(List<SituacaoServidor> listaSituacaoServidor) {
                this.listaSituacaoServidor = listaSituacaoServidor;
        }

        public List<Especialidade> getListaEspecialidade() {
                return listaEspecialidade;
        }

        public void setListaEspecialidade(List<Especialidade> listaEspecialidade) {
                this.listaEspecialidade = listaEspecialidade;
        }

        public List<Orgao> getListaOrgao() {
                return listaOrgao;
        }

        public void setListaOrgao(List<Orgao> listaOrgao) {
                this.listaOrgao = listaOrgao;
        }

        public List<Carreira> getListaCarreira() {
                return listaCarreira;
        }

        public void setListaCarreira(List<Carreira> listaCarreira) {
                this.listaCarreira = listaCarreira;
        }

        public List<SetorView> getListaSetorView() {
                return listaSetorView;
        }

        public void setListaSetorView(List<SetorView> listaSetorView) {
                this.listaSetorView = listaSetorView;
        }

        public List<Conselho> getListaConselho() {
                return listaConselho;
        }

        public void setListaConselho(List<Conselho> listaConselho) {
                this.listaConselho = listaConselho;
        }

        public List<UfView> getListaUfView() {
                return listaUfView;
        }

        public void setListaUfView(List<UfView> listaUfView) {
                this.listaUfView = listaUfView;
        }

        public List<Banco> getListaBanco() {
                return listaBanco;
        }

        public void setListaBanco(List<Banco> listaBanco) {
                this.listaBanco = listaBanco;
        }
       
        public List<ModelCampoCombo> getListaTipoClasseCarreira() {
                return listaTipoClasseCarreira;
        }

        public void setListaTipoClasseCarreira(List<ModelCampoCombo> listaTipoClasseCarreira) {
                this.listaTipoClasseCarreira = listaTipoClasseCarreira;
        }

        public List<ModelCampoCombo> getListaTipoRegimeTrabalho() {
                return listaTipoRegimeTrabalho;
        }

        public void setListaTipoRegimeTrabalho(List<ModelCampoCombo> listaTipoRegimeTrabalho) {
                this.listaTipoRegimeTrabalho = listaTipoRegimeTrabalho;
        }

        public List<ModelCampoCombo> getListaTipoNivelCarreira() {
                return listaTipoNivelCarreira;
        }

        public void setListaTipoNivelCarreira(List<ModelCampoCombo> listaTipoNivelCarreira) {
                this.listaTipoNivelCarreira = listaTipoNivelCarreira;
        }

        public void iniciarListas() {
                if(!listasInicializadas) {
                        setListaGrauInstrucao(grauInstrucaoFacade.consultarTodos(new GrauInstrucao()));
                        setListaNacionalidade(nacionalidadeFacade.consultarTodos(new Nacionalidade()));
                        setListaDeficiencia(deficienciaFacade.consultarTodos(new Deficiencia()));
                        setListaSituacaoServidor(situacaoServidorFacade.consultarTodos(new SituacaoServidor()));
                        setListaEspecialidade(especialidadeFacade.consultarTodos(new Especialidade()));
                        setListaOrgao(orgaoExternoFacade.consultarTodos(new Orgao()));
                        setListaCarreira(carreiraFacade.consultarTodos(new Carreira()));
                        setListaSetorView(setorViewFacade.consultarTodos(new SetorView()));
                        setListaConselho(conselhoFacade.consultarTodos(new Conselho()));
                        setListaUfView(ufFacade.consultarTodos(new UfView()));
                        setListaBanco(bancoFacade.consultarTodos(new Banco()));
                        setListaTipoClasseCarreira(gerarListaModelCampoComboEstatica(Arrays.asList(TipoClasseCarreira.values())));
                        setListaTipoNivelCarreira(gerarListaModelCampoComboEstatica(Arrays.asList(TipoNivelCarreira.values())));
                        setListaTipoRegimeTrabalho(gerarListaModelCampoComboEstatica(Arrays.asList(TipoRegimeTrabalho.values())));
                        listaInstituicaoEstagio = instituicaoEstagioFacade.listarInstituicaoEstagio();
                        listaCursoEstagio = cursoEstagioFacade.listarCursoEstagio();
                        listasInicializadas = true;
                }
        }

}