Subversion Repositories Integrator Subversion

package br.gov.al.saude.scs.web.managebean.turma;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.faces.bean.ManagedBean;

import org.primefaces.event.RowEditEvent;
import org.primefaces.event.TabChangeEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import br.gov.al.saude.framework.core.exception.NegocioException;
import br.gov.al.saude.framework.core.generic.GenericFacade;
import br.gov.al.saude.framework.core.model.pessoa.PessoaDTO;
import br.gov.al.saude.framework.core.util.VerificadorUtil;
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.util.URLUtils;
import br.gov.al.saude.sca.model.usuario.view.UsuarioView;
import br.gov.al.saude.scg.model.view.MunicipioView;
import br.gov.al.saude.scg.model.view.OrgaoView;
import br.gov.al.saude.scg.model.view.PessoaFisicaView;
import br.gov.al.saude.scs.core.application.municipio.MunicipioFacade;
import br.gov.al.saude.scs.core.application.perfil.PerfilFacade;
import br.gov.al.saude.scs.core.application.turma.TurmaFacade;
import br.gov.al.saude.scs.model.Capacitacao;
import br.gov.al.saude.scs.model.Perfil;
import br.gov.al.saude.scs.model.Turma;
import br.gov.al.saude.scs.model.TurmaParticipante;
import br.gov.al.saude.scs.model.TurmaPeriodo;
import br.gov.al.saude.scs.model.TurmaProcesso;
import br.gov.al.saude.scs.model.dto.ConsultaTurmaDTO;
import br.gov.al.saude.scs.model.dto.DespesasTurmaDTO;
import br.gov.al.saude.scs.model.dto.TurmaDTO;
import br.gov.al.saude.scs.parametros.ParametrosConsultarDespesasTurma;
import br.gov.al.saude.scs.parametros.ParametrosConsultarTurma;

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

        private static final long serialVersionUID = 1L;
       
        private PerfilFacade perfilFacade;
        private TurmaFacade turmaFacade;
        private MunicipioFacade municipioFacade;
       
        private TurmaConsultaDemanda consultaLazy;
        private ConsultaTurmaDTO consultaTurmaDTO = new ConsultaTurmaDTO();
        private Capacitacao capacitacaoSelecionada;
        private TurmaDtoConsultaDemanda consultaDtoLazy;
        private TurmaDTO entidadeDto;
        private ParametrosConsultarTurma parametros;
       
        private List<TurmaProcesso> processos;
        private Boolean acaoConfirmarAdicaoPecessoProcesso = false;
        private Boolean acaoCadastrar = false;
        private Integer activeIndex = 0;
       
        private OrgaoView orgao;
        private String numeroDoProcesso;
        private Integer anoDoProcesso;
        private ParametrosConsultarDespesasTurma parametrosConsultarDespesasTurma;

        private List<OrgaoView> orgaos;
        private List<Perfil> perfis;
        private List<MunicipioView> municipios;

        private DespesasTurmaDTO despesasTurma;
        private TurmaParticipante turmaParticipante = new TurmaParticipante();
        private TurmaPeriodo turmaPeriodo = new TurmaPeriodo();

        @Autowired
        public TurmaBean(TurmaFacade turmaFacade, PerfilFacade perfilFacade, MunicipioFacade municipioFacade, TurmaConsultaDemanda consultaLazy, TurmaDtoConsultaDemanda consultaDtoLazy) {
                this.turmaFacade = turmaFacade;
                this.perfilFacade = perfilFacade;
                this.municipioFacade = municipioFacade;
                this.consultaLazy = consultaLazy;
                this.consultaDtoLazy = consultaDtoLazy;
        }      
       
        @Override
        public Turma getEntidade() {
                if (VerificadorUtil.estaNulo(entidade)) {
                        entidade = new Turma();
                }
                return entidade;
        }
       
        public TurmaDTO getEntidadeDto() {
                return entidadeDto;
        }
       
        public void setEntidadeDto(TurmaDTO entidadeDto) {
                this.entidadeDto = entidadeDto;
        }
       
        @Override
        public GenericFacade<Turma> getFacade() {
                return turmaFacade;
        }

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

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

        @Override
        public void limparEntidade() {
                entidade = new Turma();
                consultaTurmaDTO = new ConsultaTurmaDTO();
                capacitacaoSelecionada = new Capacitacao();
        }
       
        @Override
        public GenericConsultaDemanda<Turma> getLazy() {
                return null;
        }
       
        public TurmaConsultaDemanda getConsultaLazy() {
                return consultaLazy;
        }
       
        public void setConsultaLazy(TurmaConsultaDemanda consultaLazy) {
                this.consultaLazy = consultaLazy;
        }
       
        public TurmaDtoConsultaDemanda getConsultaDtoLazy() {
                return consultaDtoLazy;
        }
       
        public void setConsultaDtoLazy(TurmaDtoConsultaDemanda consultaDtoLazy) {
                this.consultaDtoLazy = consultaDtoLazy;
        }
       
        public ParametrosConsultarTurma getParametros() {
                if(VerificadorUtil.estaNulo(parametros)){
                        parametros = new ParametrosConsultarTurma();
                }
                return parametros;
        }
       
        public void setParametros(ParametrosConsultarTurma parametros) {
                this.parametros = parametros;
        }
       
        public void prepararConsultaDemanda() {
                consultaLazy.setarParametrosConsulta(consultaTurmaDTO);
        }
       
        public void prepararConsultaDtoDemanda() {
                getParametros().setSequencialCapacitacao(getSequencialCapacitacaoSelecionada());
                getParametros().setUsuarioLogado((UsuarioView) getUsuario().getPrincipal());
                consultaDtoLazy.setParametros(getParametros());
                consultaDtoLazy.setConsultaInicial(true);
        }
       
        public List<OrgaoView> getListaOrgaos() {
                return orgaos;
        }
       
        public ParametrosConsultarDespesasTurma getParametrosConsultarDespesasTurma() {
                return parametrosConsultarDespesasTurma;
        }
       
        public void setParametrosConsultarDespesasTurma(ParametrosConsultarDespesasTurma parametrosConsultarDespesasTurma) {
                this.parametrosConsultarDespesasTurma = parametrosConsultarDespesasTurma;
        }
       
        public OrgaoView getOrgao() {
                return orgao;
        }

        public void setOrgao(OrgaoView orgao) {
                this.orgao = orgao;
        }

        public String getNumeroDoProcesso() {
                return numeroDoProcesso;
        }

        public void setNumeroDoProcesso(String numeroDoProcesso) {
                this.numeroDoProcesso = numeroDoProcesso;
        }

        public Integer getAnoDoProcesso() {
                return anoDoProcesso;
        }

        public void setAnoDoProcesso(Integer anoDoProcesso) {
                this.anoDoProcesso = anoDoProcesso;
        }

        public DespesasTurmaDTO getDespesasTurma() {
                return despesasTurma;
        }

        public void setDespesasTurma(DespesasTurmaDTO despesasTurma) {
                this.despesasTurma = despesasTurma;
        }
       
        public Boolean getAcaoConfirmarAdicaoPecessoProcesso() {
                return acaoConfirmarAdicaoPecessoProcesso;
        }

        public void setAcaoConfirmarAdicaoPecessoProcesso(
                        Boolean acaoConfirmarAdicaoPecessoProcesso) {
                this.acaoConfirmarAdicaoPecessoProcesso = acaoConfirmarAdicaoPecessoProcesso;
        }

        public void removerRepresentante(PessoaFisicaView representante) {
                entidade.removerRepresentante(representante);
        }
       
        public List<TurmaProcesso> getProcessos() {
                return processos;
        }
       
        public Boolean getAcaoCadastrar() {
                return acaoCadastrar;
        }

        public void setAcaoCadastrar(Boolean acaoCadastrar) {
                this.acaoCadastrar = acaoCadastrar;
        }
       
        public TurmaParticipante getTurmaParticipante() {
                return turmaParticipante;
        }

        public void setTurmaParticipante(TurmaParticipante turmaParticipante) {
                this.turmaParticipante = turmaParticipante;
        }
       
        public List<Perfil> getPerfis() {
                if(VerificadorUtil.isListaNulaOuVazia(perfis)) {
                        perfis = perfilFacade.listar();
                }
                return perfis;
        }
       
        public Integer getActiveIndex() {
                return activeIndex;
        }

        public void setActiveIndex(Integer activeIndex) {
                this.activeIndex = activeIndex;
        }
       
        public TurmaPeriodo getTurmaPeriodo() {
                return turmaPeriodo;
        }

        public void setTurmaPeriodo(TurmaPeriodo turmaPeriodo) {
                this.turmaPeriodo = turmaPeriodo;
        }
       
        public ConsultaTurmaDTO getConsultaTurmaDTO() {
                return consultaTurmaDTO;
        }

        public void setConsultaTurmaDTO(ConsultaTurmaDTO consultaTurmaDTO) {
                this.consultaTurmaDTO = consultaTurmaDTO;
        }
       
        public Capacitacao getCapacitacaoSelecionada() {
                return capacitacaoSelecionada;
        }
       
        private Long getSequencialCapacitacaoSelecionada(){
                return VerificadorUtil.naoEstaNulo(getCapacitacaoSelecionada()) ? getCapacitacaoSelecionada().getSequencial() : null;
        }

        public void setCapacitacaoSelecionada(Capacitacao capacitacaoSelecionada) {
                this.capacitacaoSelecionada = capacitacaoSelecionada;
                this.entidade.setCapacitacao(capacitacaoSelecionada);
                this.consultaTurmaDTO.setCapacitacao(capacitacaoSelecionada);
        }

        public void prepararParaAdicionarDespesas() {
                orgao = new OrgaoView();
                numeroDoProcesso = null;
                anoDoProcesso = null;
                parametrosConsultarDespesasTurma = new ParametrosConsultarDespesasTurma();
                despesasTurma = new DespesasTurmaDTO();
                acaoConfirmarAdicaoPecessoProcesso = true;
                if(VerificadorUtil.isListaNulaOuVazia(orgaos)) {
                        orgaos = turmaFacade.listarOrgaos();
                }
        }

        public void retirarSelecaoDaCapacitacao() {
                setCapacitacaoSelecionada(null);
                consultaTurmaDTO.setCapacitacao(null);
        }
       
        public void consultarDespesasTurma() {
                try {
                        despesasTurma = turmaFacade.consultarDespesasTurma(parametrosConsultarDespesasTurma);
                        orgao = parametrosConsultarDespesasTurma.getOrgao();
                        numeroDoProcesso = parametrosConsultarDespesasTurma.getNumeroProcesso();
                        anoDoProcesso = parametrosConsultarDespesasTurma.getAnoProcesso();
                } catch (NegocioException e) {
                        despesasTurma = null;
                        orgao = null;
                        numeroDoProcesso = null;
                        anoDoProcesso = null;
                        LancadorMensagem.lancarAlerta(e.getMessage());
                }catch (Exception e) {
                        LancadorMensagem.lancarErro(e.getMessage());
                }
        }
       
        public void adicionarTurmaProcesso(DespesasTurmaDTO despesasTurma) {
                TurmaProcesso turmaProcesso = new TurmaProcesso();
                turmaProcesso.setOrgao(orgao);
                turmaProcesso.setNumeroProcesso(Long.parseLong(numeroDoProcesso));
                turmaProcesso.setAno(anoDoProcesso);
                turmaProcesso.setTurma(entidade);
                turmaProcesso.setDespesasTurma(despesasTurma);
                entidade.adicionarProcesso(turmaProcesso);
        }

        public void removerTurmaProcesso(TurmaProcesso turmaProcesso) {
                entidade.removerProcesso(turmaProcesso);
        }

        public void detalharProcesso(TurmaProcesso turmaProcesso) {
                acaoConfirmarAdicaoPecessoProcesso = false;
                despesasTurma = turmaFacade.consultarDespesasTurma(new ParametrosConsultarDespesasTurma(turmaProcesso.getOrgao(), turmaProcesso.getNumeroProcesso(), turmaProcesso.getAno()));
        }

        @Override
        public void setarPessoa(final PessoaDTO pessoaDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        @Override
                        public void execute() {
                                PessoaFisicaView pessoaFisica = turmaFacade.consultarPessoa(pessoaDTO.getId());
                                if(activeIndex == 3) {
                                        turmaParticipante.setPessoa(pessoaFisica);
                                } else {
                                        entidade.adicionarRepresentante(pessoaFisica);
                                }
                        }
                });
               
        }
       
        @Override
        protected void popularObjetoSeIdPessoaDiferenteDeNulo(final String idPessoaCadastrada) {
                if(VerificadorUtil.naoEstaNuloOuVazio(idPessoaCadastrada)) {
                        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                                @Override
                                public void execute() {
                                        if (VerificadorUtil.naoEstaNuloOuVazio(idPessoaCadastrada)) {
                                                if(!idPessoaCadastrada.equals("0")) {
                                                        PessoaFisicaView pessoaFisica = turmaFacade.consultarPessoa(Long.valueOf(idPessoaCadastrada));
                                                        if(activeIndex == 3) {
                                                                turmaParticipante.setPessoa(pessoaFisica);
                                                        } else {
                                                                entidade.adicionarRepresentante(pessoaFisica);
                                                        }
                                                }
                                        }
                                }
                        });
                }
        }
       
        @Override
        public void armazenarObjetoNaSessao() {
                URLUtils.armazenarObjetoComNomeNaSessao("entidade", getEntidade());
                URLUtils.armazenarObjetoComNomeNaSessao("acaoCadastrar", acaoCadastrar);
                URLUtils.armazenarObjetoComNomeNaSessao("activeIndex", activeIndex);
        }
       
        @Override
        public void recuperarObjetoNaSessao(Boolean collapsed) {
                if(VerificadorUtil.naoEstaNuloOuVazio(collapsed)) {
                        new VerificadorLancamentoException().tratarExcecaoLimpandoObjetoDaSessao(new CommandBean() {

                                @Override
                                public void execute() {
                                        setEntidade((Turma) URLUtils.recuperarObjetoComNomeNaSessao("entidade"));
                                        URLUtils.limparObjetoDaSessaoPeloNome("entidade");
                                       
                                        acaoCadastrar = (Boolean) URLUtils.recuperarObjetoComNomeNaSessao("acaoCadastrar");
                                        URLUtils.limparObjetoDaSessaoPeloNome("acaoCadastrar");
                                       
                                        activeIndex = (Integer) URLUtils.recuperarObjetoComNomeNaSessao("activeIndex");
                                        URLUtils.limparObjetoDaSessaoPeloNome("activeIndex");
                                }
                        });
                }
        }
       
        public void prepararParaAlterar(Turma turma){
                selecionarTurma(turma);
                prepararParaAdicionarParticipantes();
        }
       
        public void prepararParaAdicionarParticipantes() {
                turmaParticipante = new TurmaParticipante();
        }
       
        public void adicionarTurmaParticipante() {
                try {
                        validarCamposTurmaParticipante(turmaParticipante);
                        verificarSeParticipanteJaFoiAdicionado(turmaParticipante);
                        turmaParticipante.setTurma(entidade);
                        turmaParticipante.setIndicadorServidor(turmaFacade.consultarIndicadorDeServidor(turmaParticipante.getPessoa()));
                        turmaFacade.verificarFaltasDoParticipante((UsuarioView) getUsuario().getPrincipal(), turmaParticipante);
                        entidade.adicionarParticipante(turmaParticipante);
                        atualizarAlertaDeRestricoesDoParticipante();
                        turmaParticipante = new TurmaParticipante();
                } catch (NegocioException ne) {
                        LancadorMensagem.lancarAlerta(ne.getMessage());
                }
        }
       
        public void removerTurmaParticipante(TurmaParticipante turmaParticipante) {
                entidade.removerParticipante(turmaParticipante);
                atualizarAlertaDeRestricoesDoParticipante();
        }
       
        public void adicionarTurmaPeriodo() {
                try {
                        validarPeriodo(turmaPeriodo);
                        turmaPeriodo.setTurma(entidade);
                        entidade.adicionarTurmaPeriodo(turmaPeriodo);
                        turmaPeriodo = new TurmaPeriodo();
                } catch (NegocioException ne) {
                        LancadorMensagem.lancarAlerta(ne.getMessage());
                }
        }
       
        private void validarPeriodo(TurmaPeriodo turmaPeriodo) {
                StringBuilder mensagem = new StringBuilder();
                String separador = "";
               
                if(VerificadorUtil.estaNulo(turmaPeriodo.getDataInicial())) {
                        mensagem.append(separador);
                        mensagem.append("Obrigatório informar a data inicial.");
                        separador = "; ";
                }
               
                if(VerificadorUtil.estaNulo(turmaPeriodo.getDataFinal())) {
                        mensagem.append(separador);
                        mensagem.append("Obrigatório informar a data final.");
                }
               
                if(VerificadorUtil.naoEstaNulo(turmaPeriodo.getDataInicial()) && VerificadorUtil.naoEstaNulo(turmaPeriodo.getDataFinal())) {
                        if(turmaPeriodo.getDataInicial().after(turmaPeriodo.getDataFinal())) {
                                mensagem.append("Data inicial não pode ser maior que a final.");
                        }
                }
               
                if(VerificadorUtil.naoEstaNuloOuVazio(mensagem.toString())) {
                        throw new NegocioException(mensagem.toString());
                }
        }

        public void removerPeriodo(TurmaPeriodo turmaPeriodo) {
                entidade.removerTurmaPeriodo(turmaPeriodo);
        }
       
        public void selecionarTurma(Turma turma) {
                entidade = turmaFacade.detalharTurma(turma.getSequencial());
                atualizarIndicadorServidor();
                atualizarAlertaDeRestricoesDoParticipante();
                listarMunicipios();
        }

        public void detalharTurma(Turma turma) {
                entidade = turmaFacade.detalharTurma(turma.getSequencial());
                atualizarIndicadorServidor();
                atualizarAlertaDeRestricoesDoParticipante();
        }

        private void verificarSeParticipanteJaFoiAdicionado(TurmaParticipante turmaParticipante) {
                if(entidade.getParticipantes().contains(turmaParticipante)) {
                        throw new NegocioException("Este participante já foi adicionado.");
                }
        }

        private void validarCamposTurmaParticipante(TurmaParticipante turmaParticipante) {
                StringBuilder mensagem = new StringBuilder();
                String separador = "";
               
                if(VerificadorUtil.estaNulo(turmaParticipante.getPessoa())) {
                        mensagem.append(separador);
                        mensagem.append("Obrigatório informar o Representante.");
                        separador = "; ";
                }
               
                if(VerificadorUtil.estaNulo(turmaParticipante.getPerfil())) {
                        mensagem.append(separador);
                        mensagem.append("Obrigatório informar o Perfil.");
                        separador = "; ";
                }

                if(VerificadorUtil.estaNulo(turmaParticipante.getIndicadorRemunerado())) {
                        mensagem.append(separador);
                        mensagem.append("Obrigatório informar Indicador Remunerado.");
                        separador = "; ";
                }
               
                if(VerificadorUtil.naoEstaNuloOuVazio(mensagem.toString())) {
                        throw new NegocioException(mensagem.toString());
                }
        }
       
        public void onEditRow(RowEditEvent event) {
       atualizarAlertaDeRestricoesDoParticipante();
    }
       
        public void listarMunicipios(){
                if(VerificadorUtil.naoEstaNulo(entidade.getUf())) {
                        municipios = municipioFacade.listar(entidade.getUf().getCodigo());
                } else {
                        municipios = new ArrayList<MunicipioView>();
                }
        }
       
        public List<MunicipioView> getMunicipios() {
                return municipios;
        }
       
        public void onChange(TabChangeEvent event) {
                if(VerificadorUtil.estaNulo(entidade.getAnoExercicio())) {
                        LancadorMensagem.lancarAlerta("Informe o ano de exercício na aba Turma para ter uma informação real do indicador de restrição do participante.");
                }
        }

        private void atualizarAlertaDeRestricoesDoParticipante() {
                for (TurmaParticipante turmaParticipante : entidade.getParticipantes()) {
                        try {
                                turmaFacade.verificarAlertaDeRestricaoDoParticipante(turmaParticipante, new ArrayList<TurmaParticipante>(entidade.getParticipantes()));
                                turmaParticipante.setIndicadorRestricao(false);
                        } catch (NegocioException e) {
                                turmaParticipante.setIndicadorRestricao(true);
                        }
                }
        }

        private void atualizarIndicadorServidor() {
                for (TurmaParticipante turmaParticipante : entidade.getParticipantes()) {
                        turmaParticipante.setIndicadorServidor(turmaFacade.consultarIndicadorDeServidor(turmaParticipante.getPessoa()));
                }
        }
               
}