Subversion Repositories Integrator Subversion

package br.edu.cesmac.sic.controller.beans;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.inject.Named;
import javax.persistence.Transient;

import org.primefaces.model.StreamedContent;
import org.springframework.context.annotation.Scope;

import br.edu.cesmac.core.consulta.ParametrosConsulta;
import br.edu.cesmac.core.generic.GenericService;
import br.edu.cesmac.core.util.VerificadorUtil;
import br.edu.cesmac.relatorio.util.RelatorioUtils;
import br.edu.cesmac.sca.seguranca.authentication.context.ContextoSeguranca;
import br.edu.cesmac.sic.controller.beans.consultademanda.ProjetoPesquisaConsultaPorDemanda;
import br.edu.cesmac.sic.core.domain.model.Avaliacao;
import br.edu.cesmac.sic.core.domain.model.Avaliador;
import br.edu.cesmac.sic.core.domain.model.ProjetoPesquisa;
import br.edu.cesmac.sic.core.domain.model.ProjetoPesquisaAvaliador;
import br.edu.cesmac.sic.core.domain.model.Questao;
import br.edu.cesmac.sic.core.domain.model.Resposta;
import br.edu.cesmac.sic.core.domain.model.dto.TopicoQuestaoDTO;
import br.edu.cesmac.sic.core.domain.model.tipo.TipoConceitoGlobal;
import br.edu.cesmac.sic.core.domain.model.tipo.TipoTopico;
import br.edu.cesmac.sic.core.domain.service.AvaliacaoService;
import br.edu.cesmac.sic.core.domain.service.AvaliadorService;
import br.edu.cesmac.sic.core.domain.service.EmissorRelatorioService;
import br.edu.cesmac.sic.core.domain.service.ProjetoPesquisaService;
import br.edu.cesmac.sic.core.domain.service.QuestaoService;
import br.edu.cesmac.sic.core.domain.service.RespostaService;
import br.edu.cesmac.web.exception.VerificadorLancamentoException;
import br.edu.cesmac.web.exception.VerificadorLancamentoException.CommandBean;
import br.edu.cesmac.web.exception.VerificadorLancamentoException.CommandRelatorioStreamedContent;
import br.edu.cesmac.web.generic.AbstractBean;
import br.edu.cesmac.web.message.LancadorMensagem;
import br.edu.cesmac.web.util.TipoOperacao;
import net.sf.jasperreports.engine.JasperPrint;

@Named
@Scope("view")
public class AvaliacaoBean extends AbstractBean<ProjetoPesquisa> implements Serializable {

        private static final long serialVersionUID = 1L;
       
        private ProjetoPesquisaConsultaPorDemanda lazy;
        private List<Resposta> respostas;
        private List<ProjetoPesquisa> projetosPesquisaDisponiveis;
        private Avaliacao avaliacaoSelecionada;

        private ProjetoPesquisaService projetoPesquisaService;
        private QuestaoService questaoService;
        private RespostaService respostaService;
        private AvaliacaoService avaliacaoService;
        private AvaliadorService avaliadorService;
        private EmissorRelatorioService emissorRelatorioService;
       
        private ContextoSeguranca contextoSeguranca;
       
        @Inject
        public AvaliacaoBean(ProjetoPesquisaConsultaPorDemanda lazy, ProjetoPesquisaService projetoPesquisaService, QuestaoService questaoService,
                        RespostaService respostaService, AvaliacaoService avaliacaoService, AvaliadorService avaliadorService, EmissorRelatorioService emissorRelatorioService,
                        ContextoSeguranca contextoSeguranca) {
                this.lazy = lazy;
                this.projetoPesquisaService = projetoPesquisaService;
                this.questaoService = questaoService;
                this.respostaService = respostaService;
                this.avaliacaoService = avaliacaoService;
                this.avaliadorService = avaliadorService;
                this.contextoSeguranca = contextoSeguranca;
        }

        @Override
        public ProjetoPesquisa getId() {
                return getEntidade();
        }

        @Override
        public GenericService<ProjetoPesquisa> getService() {
                return projetoPesquisaService;
        }

        @Override
        public void limparEntidade() {
                setEntidade(new ProjetoPesquisa());
                setAvaliacaoSelecionada(null);
        }
       
        @Override
        public ProjetoPesquisa getEntidade() {
                return entidade;
        }

        public ProjetoPesquisaConsultaPorDemanda getLazy() {
                return lazy;
        }
       
        public void prepararConsultaDemanda() {
                lazy.setarParametrosConsulta(getParametrosConsulta());
        }
       
        public List<Resposta> getRespostas() {
                return respostas;
        }
       
        @Transient
        public List<TopicoQuestaoDTO> getTopicosOrdenados() {
                List<TopicoQuestaoDTO> topicos = new ArrayList<TopicoQuestaoDTO>();
                if (VerificadorUtil.naoEstaNulo(getRespostas())) {
                        adicionarRespostasDoTopico(topicos, null);
                        adicionarRespostasDoTopico(topicos, TipoTopico.INTRODUCAO.getValue());
                        adicionarRespostasDoTopico(topicos, TipoTopico.OBJETIVOS.getValue());
                        adicionarRespostasDoTopico(topicos, TipoTopico.METODOLOGIA.getValue());
                        adicionarRespostasDoTopico(topicos, TipoTopico.REFERENCIAS.getValue());
                        adicionarRespostasDoTopico(topicos, TipoTopico.PLANO_ATIVIDADES_CRONOGRAMA.getValue());
                }
                return topicos;
        }
       
        private void adicionarRespostasDoTopico(List<TopicoQuestaoDTO> topicos, String tipoTopico) {
                TopicoQuestaoDTO topico = new TopicoQuestaoDTO(tipoTopico);
                for (Resposta resposta : getRespostasOrdenadas()) {
                        if (VerificadorUtil.naoEstaNulo(resposta.getQuestao().getTipoTopico())) {
                                if (resposta.getQuestao().getTipoTopico().equals(tipoTopico)) {
                                        topico.getRespostas().add(resposta);
                                }
                        } else if (VerificadorUtil.estaNulo(tipoTopico)) {
                                topico.getRespostas().add(resposta);
                        }
                }
                topicos.add(topico);
        }

        @Transient
        public List<Resposta> getRespostasOrdenadas() {
                List<Resposta> respostasOrdenadas = null;
                if (VerificadorUtil.naoEstaNulo(getRespostas())) {
                        respostasOrdenadas = new ArrayList<Resposta>(getRespostas());
                        Collections.sort(respostasOrdenadas, new Comparator<Resposta>() {
                                public int compare(Resposta r1, Resposta r2) {
                                        return r1.getQuestao().getNumeroQuestao().compareTo(r2.getQuestao().getNumeroQuestao());
                                };
                        });
                }
                return respostasOrdenadas;
        }
       
        public void setRespostas(List<Resposta> respostas) {
                this.respostas = respostas;
        }
       
        public List<ProjetoPesquisa> getProjetosPesquisaDisponiveis() {
                return projetosPesquisaDisponiveis;
        }
       
        public void setProjetosPesquisaDisponiveis(List<ProjetoPesquisa> projetosPesquisaDisponiveis) {
                this.projetosPesquisaDisponiveis = projetosPesquisaDisponiveis;
        }
       
        public Avaliacao getAvaliacaoSelecionada() {
                return avaliacaoSelecionada;
        }
       
        public void setAvaliacaoSelecionada(Avaliacao avaliacaoSelecionada) {
                this.avaliacaoSelecionada = avaliacaoSelecionada;
        }
       
        public Double getPontuacaoTotal() {
                Double pontuacaoTotal = new Double(0.0);
                for (Resposta resposta : getRespostas()) {
                        pontuacaoTotal = pontuacaoTotal + resposta.getValorPontuacao();
                }
                return pontuacaoTotal;
        }
       
        @PostConstruct
        public void preCarregamento() {
                parametrosConsulta = new ParametrosConsulta<ProjetoPesquisa>();
                parametrosConsulta.setEntidade(new ProjetoPesquisa());
                prepararConsultaDemanda();
                Avaliador avaliador = avaliadorService.consultarAvaliadorPorPessoa(contextoSeguranca.obterUsuario().getPessoa());
                setProjetosPesquisaDisponiveis(projetoPesquisaService.consultarProjetosPesquisaDisponiveisDoAvaliador(avaliador));
        }
       
        @Override
        public void preRealizar() {
                setTipoOperacao(TipoOperacao.REALIZAR);
        }
       
        public List<ProjetoPesquisa> getProjetosPesquisaNaoAvaliados() {
                return projetoPesquisaService.consultarProjetosPesquisaNaoAvaliados(null, null);
        }
       
        public void preAvaliar(ProjetoPesquisa projetoPesquisa) {
                Avaliador avaliador = avaliadorService.consultarAvaliadorPorPessoa(contextoSeguranca.obterUsuario().getPessoa());
                Avaliacao avaliacao = avaliacaoService.consultarAvaliacaoDoAvaliador(projetoPesquisa, avaliador);
                if (VerificadorUtil.naoEstaNulo(avaliacao)) {
                        setRespostas(new ArrayList<Resposta>(avaliacao.getRespostas()));
                        setAvaliacaoSelecionada(avaliacao);
                } else {
                        avaliacao = new Avaliacao();
                        ProjetoPesquisaAvaliador projetoPesquisaAvaliador = new ProjetoPesquisaAvaliador();
                        projetoPesquisaAvaliador.setProjetoPesquisa(projetoPesquisa);
                        avaliacao.setProjetoPesquisaAvaliador(projetoPesquisaAvaliador);
                        preencherQuestoesParaRespostas(avaliacao);
                        setAvaliacaoSelecionada(avaliacao);
                }
                setEntidade(projetoPesquisaService.detalharProjetoPesquisa(projetoPesquisa));
                preRealizar();
        }
       
        public void preReavaliar(ProjetoPesquisa projetoPesquisa) {
                setEntidade(projetoPesquisa);
                Avaliador avaliador = avaliadorService.consultarAvaliadorPorPessoa(contextoSeguranca.obterUsuario().getPessoa());
                setAvaliacaoSelecionada(avaliacaoService.consultarAvaliacaoDoAvaliador(projetoPesquisa, avaliador));
                setRespostas(new ArrayList<Resposta>(getAvaliacaoSelecionada().getRespostas()));
                preRealizar();
        }
       
        @Override
        public void preAlterar(ProjetoPesquisa projetoPesquisa) {
                super.preAlterar(projetoPesquisa);
//              setRespostas(respostaService.consultarRespostasDoProjetoPesquisa(projetoPesquisa));
        }
       
        public void selecionarAvaliacaoParaConsulta(Avaliacao avaliacao) {
                setAvaliacaoSelecionada(avaliacaoService.consultarAvaliacaoDoAvaliador(avaliacao.getProjetoPesquisaAvaliador().getProjetoPesquisa(), avaliacao.getProjetoPesquisaAvaliador().getAvaliador()));
                setRespostas(new ArrayList<Resposta>(getAvaliacaoSelecionada().getRespostas()));
        }
       
        private void preencherQuestoesParaRespostas(Avaliacao avaliacao) {
                List<Resposta> respostas = new ArrayList<Resposta>();
                List<Questao> questoesAtivas = questaoService.consultarQuestoesAtivas();
                for (Questao questao : questoesAtivas) {
                        Resposta resposta = new Resposta();
                        resposta.setQuestao(questao);
                        resposta.setAvaliacao(avaliacao);
                        resposta.setValorPontuacao(new Double(0.0));
                        respostas.add(resposta);
                }
                setRespostas(respostas);
        }
       
        public TipoConceitoGlobal[] getTiposConceitoGlobal() {
                return TipoConceitoGlobal.values();
        }
       
        public void confirmarAvaliacao() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                ProjetoPesquisaAvaliador projetoPesquisaAvaliador = new ProjetoPesquisaAvaliador();
                                projetoPesquisaAvaliador.setProjetoPesquisa(getEntidade());
                                projetoPesquisaAvaliador.setAvaliador(avaliadorService.consultarAvaliadorPorPessoa(contextoSeguranca.obterUsuario().getPessoa()));
                                getAvaliacaoSelecionada().setProjetoPesquisaAvaliador(projetoPesquisaAvaliador);
                                getAvaliacaoSelecionada().setRespostas(new HashSet<Resposta>(getRespostas()));
                                avaliacaoService.alterar(getAvaliacaoSelecionada());
                                preConsultar();
                                LancadorMensagem.lancarSucesso(getMensagens().get(IDENTIFICADOR_MENSAGEM_CADASTRADO_COM_SUCESSO));
                        }
                });
        }
       
        public String descricaoDoTipoConceitoGlobal(String tipoConceitoGlobal) {
                return TipoConceitoGlobal.parse(tipoConceitoGlobal).getDescricao();
        }
       
        public void validarAvaliacao() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                /*
                                getEntidade().getProjetoPesquisaAvaliacao().setIndicadorValidacao(true);
                                */
                                projetoPesquisaService.alterar(getEntidade());
                                preConsultar();
                                LancadorMensagem.lancarSucesso("Avaliação validada com sucesso");
                        }
                });
        }
       
        public Boolean avaliadorFezAvaliacaoDoProjeto(ProjetoPesquisa projetoPesquisa) {
                Avaliador avaliador = avaliadorService.consultarAvaliadorPorPessoa(contextoSeguranca.obterUsuario().getPessoa());
                return VerificadorUtil.naoEstaNulo(avaliacaoService.consultarAvaliacaoDoAvaliador(projetoPesquisa, avaliador));
        }
       
        public StreamedContent emitirAvaliacao() {
                return new VerificadorLancamentoException().verificarLancamentoException(new CommandRelatorioStreamedContent() {
                        @Override
                        public StreamedContent execute() {
                                JasperPrint relatorio = emissorRelatorioService.emitirAvaliacao(getAvaliacaoSelecionada());
                                return RelatorioUtils.gerarPdf(relatorio, relatorio.getName());
                        }
                });
        }
       
}