Subversion Repositories Integrator Subversion

package br.gov.al.saude.rhd.core.aceitacao.plugin;

import static br.gov.al.saude.test.ConstantesTestHelper.PRIMEIRO_REGISTRO_0;
import static br.gov.al.saude.test.ConstantesTestHelper.TAMANHO_DA_PAGINA_5;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.DADOS_EXIBIDOS_VAZIO;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.DADOS_GRAVADOS_COM_SUCESSO;
import static br.gov.al.saude.test.ConstantesTestHelper.MensagensRetorno.MENSAGEM_ARQUIVO_ACATADO_COM_SUCESSO;
import static br.gov.al.saude.test.ConstantesTestHelper.PessoaConstantes.SEQUENCIAL_PESSOA_LUCIANO_BARBOSA_1;
import static br.gov.al.saude.test.util.ConversorDeTipo.converterStringParaLong;
import static br.gov.al.saude.test.util.StringUtils.valueInt;
import static br.gov.al.saude.test.util.StringUtils.valueLong;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

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

import org.springframework.beans.factory.annotation.Autowired;

import br.gov.al.saude.framework.core.consulta.restricao.Restricoes;
import br.gov.al.saude.framework.core.util.VerificadorUtil;
import br.gov.al.saude.rhd.core.application.avaliacao.AvaliacaoFacade;
import br.gov.al.saude.rhd.core.application.avaliacaodesempenho.AvaliacaoDesempenhoFacade;
import br.gov.al.saude.rhd.core.application.cronograma.CronogramaFacade;
import br.gov.al.saude.rhd.core.application.emissorrelatorio.EmissorRelatorioFacade;
import br.gov.al.saude.rhd.core.application.grupoavaliacao.GrupoAvaliacaoFacade;
import br.gov.al.saude.rhd.core.application.pessoa.PessoaFisicaViewFacade;
import br.gov.al.saude.rhd.core.application.servidor.ServidorFacade;
import br.gov.al.saude.rhd.core.application.servidoravaliacao.ServidorAvaliacaoFacade;
import br.gov.al.saude.rhd.core.application.servidorfalta.ServidorFaltaFacade;
import br.gov.al.saude.rhd.core.application.unidade.UnidadeFacade;
import br.gov.al.saude.rhd.model.Avaliacao;
import br.gov.al.saude.rhd.model.AvaliacaoDesempenho;
import br.gov.al.saude.rhd.model.Cronograma;
import br.gov.al.saude.rhd.model.CronogramaEtapa;
import br.gov.al.saude.rhd.model.Etapa;
import br.gov.al.saude.rhd.model.GrupoAvaliacao;
import br.gov.al.saude.rhd.model.QualificacaoServidorCronograma;
import br.gov.al.saude.rhd.model.QuestaoAvaliacaoDesempenho;
import br.gov.al.saude.rhd.model.RevisaoAvaliacao;
import br.gov.al.saude.rhd.model.RevisaoAvaliacaoDesempenho;
import br.gov.al.saude.rhd.model.RevisaoAvaliacaoDesempenhoId;
import br.gov.al.saude.rhd.model.ServidorAvaliacao;
import br.gov.al.saude.rhd.model.ServidorAvaliacaoId;
import br.gov.al.saude.rhd.model.dto.RevisaoAvaliacaoDTO;
import br.gov.al.saude.rhd.model.dto.ServidorAvaliacaoDTO;
import br.gov.al.saude.rhd.model.dto.ServidorDadoFuncionalViewDTO;
import br.gov.al.saude.rhd.model.dto.ServidorFaltasMesAhMesDTO;
import br.gov.al.saude.rhd.model.view.QualificacaoServidorView;
import br.gov.al.saude.rhd.model.view.ServidorDadoFuncionalView;
import br.gov.al.saude.rhd.model.view.ServidorView;
import br.gov.al.saude.rhd.model.view.UnidadeView;
import br.gov.al.saude.rhd.parametros.ParametroEmissaoRelatorioDTO;
import br.gov.al.saude.rhd.parametros.ParametrosConsultarGrupoAvaliacao;
import br.gov.al.saude.rhd.parametros.ParametrosConsultarRevisaoAvaliacaoNaoRespondida;
import br.gov.al.saude.rhd.parametros.ParametrosConsultarServidorAvaliacaoAvaliadoPorAvaliador;
import br.gov.al.saude.rhd.parametros.ParametrosConsultarServidorAvaliacaoDisponivelParaOhGrupoAvaliacao;
import br.gov.al.saude.sca.model.usuario.view.UsuarioView;
import br.gov.al.saude.scg.model.view.PessoaFisicaView;
import br.gov.al.saude.test.aceitacao.helper.CenarioTestHelper;
import br.gov.al.saude.test.aceitacao.plugin.TestPlugin;
import br.gov.al.saude.test.builder.AvaliacaoDesempenhoBuilder;
import br.gov.al.saude.test.builder.CronogramaBuilder;
import br.gov.al.saude.test.builder.CronogramaEtapaBuilder;
import br.gov.al.saude.test.builder.EtapaBuilder;
import br.gov.al.saude.test.builder.GrupoAvaliacaoBuilder;
import br.gov.al.saude.test.builder.ParametroEmissaoRelatorioBuilder;
import br.gov.al.saude.test.builder.PessoaFisicaViewBuilder;
import br.gov.al.saude.test.builder.QualificacaoServidorBuilder;
import br.gov.al.saude.test.builder.RevisaoAvaliacaoBuilder;
import br.gov.al.saude.test.builder.RevisaoAvaliacaoDesempenhoBuilder;
import br.gov.al.saude.test.builder.ServidorAvaliacaoBuilder;
import br.gov.al.saude.test.builder.ServidorAvaliacaoIdBuilder;
import br.gov.al.saude.test.builder.ServidorDadoFuncionalViewBuilder;
import br.gov.al.saude.test.builder.ServidorViewBuilder;
import br.gov.al.saude.test.builder.UnidadeViewBuilder;
import br.gov.al.saude.test.builder.UsuarioViewBuilder;
import br.gov.al.saude.test.util.Command;
import br.gov.al.saude.test.util.VerificadorLancamentoException;

import com.itextpdf.text.pdf.PdfReader;
import com.itextpdf.text.pdf.parser.PdfTextExtractor;

public class ApiTestPlugin implements TestPlugin {

        private static Integer PRIMEIRO_REGISTRO_ZERO = valueInt(PRIMEIRO_REGISTRO_0);

        private CenarioTestHelper cenarioTestHelper;

        private ServidorFacade servidorFacade;
        private CronogramaFacade cronogramaFacade;
        private ServidorAvaliacaoFacade servidorAvaliacaoFacade;
        private AvaliacaoDesempenhoFacade avaliacaoDesempenhoFacade;
        private GrupoAvaliacaoFacade grupoAvaliacaoFacade;
        private ServidorFaltaFacade servidorFaltaFacade;
        private AvaliacaoFacade avaliacaoFacade;
        private UnidadeFacade unidadeFacade;
        private EmissorRelatorioFacade emissorRelatorioFacade;
        private PessoaFisicaViewFacade pessoaFisicaViewFacade;

        public void setUp() throws Exception {
                cenarioTestHelper.limparBanco();
        }

        public void tearDown() throws Exception {
                cenarioTestHelper.limparBanco();
        }

        @Autowired
        public ApiTestPlugin(CenarioTestHelper cenarioTestHelper, ServidorFacade servidorFacade, CronogramaFacade cronogramaFacade,
                        AvaliacaoDesempenhoFacade avaliacaoDesempenhoFacade, ServidorAvaliacaoFacade servidorAvaliacaoFacade, GrupoAvaliacaoFacade grupoAvaliacaoFacade,
                        ServidorFaltaFacade servidorFaltaFacade, AvaliacaoFacade avaliacaoFacade, UnidadeFacade unidadeFacade, EmissorRelatorioFacade emissorRelatorioFacade,
                        PessoaFisicaViewFacade pessoaFisicaViewFacade) {
                this.cenarioTestHelper = cenarioTestHelper;
                this.servidorFacade = servidorFacade;
                this.cronogramaFacade = cronogramaFacade;
                this.servidorAvaliacaoFacade = servidorAvaliacaoFacade;
                this.avaliacaoDesempenhoFacade = avaliacaoDesempenhoFacade;
                this.grupoAvaliacaoFacade = grupoAvaliacaoFacade;
                this.servidorFaltaFacade = servidorFaltaFacade;
                this.avaliacaoFacade = avaliacaoFacade;
                this.unidadeFacade = unidadeFacade;
                this.emissorRelatorioFacade = emissorRelatorioFacade;
                this.pessoaFisicaViewFacade = pessoaFisicaViewFacade;
        }

        @Override
        public String consultarDadosPessoais(final String sequencialPessoa) {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<ServidorView> listaServidores = new ArrayList<ServidorView>();    
                                listaServidores.add(servidorFacade.consultarDadosPessoais(valueLong(sequencialPessoa)));
                                return cenarioTestHelper.gerarMensagemConsultar(listaServidores);
                        }
                });
        }

        @Override
        public String consultarCronograma(final String ano) {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<Cronograma> listaCronograma = cronogramaFacade.consultarCronogramaPorNumeroAno(valueLong(ano));
                                return cenarioTestHelper.gerarMensagemConsultar(listaCronograma);
                        }
                });
        }

        @Override
        public String cadastrarCronograma(final String ano, final String listaEtapas) {
                final Cronograma cronograma = new CronogramaBuilder().comNumeroAno(ano).build();
                final List<CronogramaEtapa> listaCronogramaEtapa = criarCronogramaEtapa(cronograma, listaEtapas);
                for (CronogramaEtapa cronogramaEtapa : listaCronogramaEtapa) {
                        cronograma.adicionarCronogramaEtapa(cronogramaEtapa);
                }
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                cronogramaFacade.cadastrar(cronograma);
                                List<Cronograma> cronogramasBuscados = cenarioTestHelper.consultarCronogramaEtapa(ano);
                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagemConsultar(cronogramasBuscados);
                        }
                });
        }

        @Override
        public String alterarCronograma(final String ano, String listaEtapas, String sequencialUsuarioSca) {
                final Cronograma cronograma = new CronogramaBuilder().comNumeroAno(ano).build();
                final List<CronogramaEtapa> listaCronogramaEtapa = criarCronogramaEtapa(cronograma, listaEtapas);
                final UsuarioView usuario = new UsuarioViewBuilder().comSequencial(sequencialUsuarioSca).build();
                for (CronogramaEtapa cronogramaEtapa : listaCronogramaEtapa) {
                        cronograma.adicionarCronogramaEtapa(cronogramaEtapa);                                  
                }
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                cronogramaFacade.alterarCronogramaInserindoHistorico(cronograma, usuario);
                                Cronograma crongramaAlterado = cenarioTestHelper.consultarCronogramaPorId(cronograma);
                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagemComHistorico(crongramaAlterado);
                        }
                });
        }

        @Override
        public String consultarParticipacaoDoServidor(String anoCorrente, String sequencialUnidadeExercicio, String nomeServidor, String matricula, String efetivoExercicio) {
                final List<Restricoes> restricoes = new ArrayList<Restricoes>();
                adicionarRestricaoCronogramaCasoSejaInformado(anoCorrente, restricoes);
                adicionarRestricaoEfetivoExercicioCasoSejaInformado(efetivoExercicio, restricoes);
                adicionarRestricaoMatriculaDadoFuncionalCasoSejaInformado(matricula, restricoes);
                adicionarRestricaoNomeServidorCasoSejaInformado(nomeServidor, restricoes);
                adicionarRestricaoUnidadeExercicioCasoSejaInformado(sequencialUnidadeExercicio, restricoes);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<ServidorDadoFuncionalViewDTO> listaServidorDadoFuncionalViewDTO = servidorFacade.listarServidorDadoFuncionalParticipacaoAvaliacaoPorDemanda(restricoes, PRIMEIRO_REGISTRO_ZERO, Integer.MAX_VALUE);
                                return cenarioTestHelper.gerarMensagem(listaServidorDadoFuncionalViewDTO.toArray());
                        }
                });
        }

        @Override
        public String alterarEfetivoExercicioDoServidor(String sequencialDadoFuncional, String anoCronograma, String efetivoExercicio, String justificativa) {                         
                Cronograma cronograma = new CronogramaBuilder()
                                                                        .comNumeroAno(anoCronograma)
                                                                        .build();
                ServidorDadoFuncionalView dadoFuncional = new ServidorDadoFuncionalViewBuilder()
                                                                                                          .comSequencial(sequencialDadoFuncional)
                                                                                                          .build();
                final ServidorAvaliacao servidorAvaliacao = new ServidorAvaliacaoBuilder()
                                                                                                                .comCronograma(cronograma)
                                                                                                                .comDadoFuncional(dadoFuncional)
                                                                                                                .comTipoEfetivoExercicio(efetivoExercicio)
                                                                                                                .comDescricaoJustificativa(justificativa)
                                                                                                                .build();
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                servidorAvaliacaoFacade.alterar(servidorAvaliacao);
                                ServidorAvaliacao servidorAvaliacaoConsultado = cenarioTestHelper.consultarServidorAvaliacaoPorId(servidorAvaliacao);
                                return cenarioTestHelper.gerarMensagemServidorAvaliacaoResumido(servidorAvaliacaoConsultado);
                        }
                });
        }
       
        @Override
        public String consultarGrupoAvaliacao(String sequencialUsuarioLogado, String anoCronograma,
                                                                                  String sequencialUnidadeExercicio, String situacaoGrupo,
                                                                                  String descricaoGrupo) {
                UsuarioView usuarioLogado  = cenarioTestHelper.consultarUsuarioPorId(sequencialUsuarioLogado);
                Cronograma cronograma = new CronogramaBuilder().comNumeroAno(anoCronograma).build();
                UnidadeView unidadeExercicio = criarUnidade(sequencialUnidadeExercicio);
                final ParametrosConsultarGrupoAvaliacao parametros = new ParametrosConsultarGrupoAvaliacao(usuarioLogado, cronograma, unidadeExercicio,
                                                                                                                                                                                                 situacaoGrupo, descricaoGrupo, Integer.MAX_VALUE,
                                                                                                                                                                                                 PRIMEIRO_REGISTRO_ZERO);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<GrupoAvaliacao> listaGrupoAvaliacao = grupoAvaliacaoFacade.consultarGrupoAvaliacao(parametros);
                                return cenarioTestHelper.gerarMensagem(listaGrupoAvaliacao.toArray(new Object[0]));
                        }
                });
        }
       
        @Override
        public String detalharGrupoAvaliacao(String sequencialDoGrupoDeAvaliacao) {
                final GrupoAvaliacao grupoAvaliacao = new GrupoAvaliacaoBuilder().comSequencial(sequencialDoGrupoDeAvaliacao).build();

                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                GrupoAvaliacao grupoAvaliacaoConsultado = grupoAvaliacaoFacade.detalharGrupoAvaliacao(grupoAvaliacao);
                                return cenarioTestHelper.gerarMensagemAuxiliar(grupoAvaliacaoConsultado);
                        }
                });
        }
       
        @Override
        public String cadastrarGrupoAvaliacao(String descricao, String sequencialPessoaAvaliador, String listaAvaliados,
                                                                                  String sequencialUnidade, String anoCronograma) {
                Cronograma cronograma = criarCronograma(anoCronograma);
                final GrupoAvaliacao grupoAvaliacao = new GrupoAvaliacaoBuilder()
                                                                                                  .comDescricao(descricao)
                                                                                                  .comUnidade(criarUnidade(sequencialUnidade))
                                                                                                  .comServidorAvaliador(criarAvaliador(sequencialPessoaAvaliador))
                                                                                                  .comCronograma(cronograma)
                                                                                                  .build();
                Set<ServidorAvaliacao> servidoresAvaliados = criarServidoresAvaliacao(listaAvaliados, grupoAvaliacao, cronograma);
                grupoAvaliacao.setServidoresAvaliados(servidoresAvaliados);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                grupoAvaliacaoFacade.cadastrar(grupoAvaliacao);
                                GrupoAvaliacao grupoAvaliacaoConsultado = cenarioTestHelper.consultarGrupoAvaliacaoPorId(grupoAvaliacao);
                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagemAuxiliar(grupoAvaliacaoConsultado);
                        }
                });
        }

        @Override
        public String alterarGrupoAvaliacao(String sequencialGrupo, String descricao, String sequencialPessoaAvaliador,
                                                                                String listaAvaliados, String observacao) {
                GrupoAvaliacao grupoAvaliacaoBuscado = cenarioTestHelper.consultarGrupoAvaliacaoPorSequencial(converterStringParaLong(sequencialGrupo));
                Set<ServidorAvaliacao> servidoresAvaliados = criarServidoresAvaliacao(listaAvaliados, grupoAvaliacaoBuscado);
                final GrupoAvaliacao grupoAvaliacaoAlterado = new GrupoAvaliacaoBuilder(grupoAvaliacaoBuscado)
                                                                                                                  .comDescricao(descricao)
                                                                                                                  .comServidorAvaliador(criarAvaliador(sequencialPessoaAvaliador))
                                                                                                                  .comServidoresAvaliados(servidoresAvaliados)
                                                                                                                  .comObservacao(observacao)
                                                                                                                  .build();
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                grupoAvaliacaoFacade.alterar(grupoAvaliacaoAlterado);
                                GrupoAvaliacao grupoAvaliacaoConsultado = cenarioTestHelper.consultarGrupoAvaliacaoPorId(grupoAvaliacaoAlterado);
                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagemAuxiliar(grupoAvaliacaoConsultado);
                        }
                });
        }

        @Override
        public String confirmarFormacaoDoGrupoAvaliacao(String sequencialGrupo, String observacao) {
                final GrupoAvaliacao grupoAvaliacao = cenarioTestHelper.consultarGrupoAvaliacaoPorId(new GrupoAvaliacaoBuilder().comSequencial(sequencialGrupo).build());
                grupoAvaliacao.setObservacao(observacao);

                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                grupoAvaliacaoFacade.confirmarFormacaoDoGrupoAvaliacao(grupoAvaliacao);
                                GrupoAvaliacao grupoAvaliacaoConsultado = cenarioTestHelper.consultarGrupoAvaliacaoPorId(grupoAvaliacao);
                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagemAuxiliar(grupoAvaliacaoConsultado);
                        }
                });
        }
       
        @Override
        public String rejeitarFormacaoDoGrupoAvaliacao(String sequencialGrupo, String observacao) {
                final GrupoAvaliacao grupoAvaliacao = cenarioTestHelper.consultarGrupoAvaliacaoPorId(new GrupoAvaliacaoBuilder().comSequencial(sequencialGrupo).build());
                grupoAvaliacao.setObservacao(observacao);

                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                grupoAvaliacaoFacade.rejeitarFormacaoDoGrupoAvaliacao(grupoAvaliacao);
                                GrupoAvaliacao grupoAvaliacaoConsultado = cenarioTestHelper.consultarGrupoAvaliacaoPorId(grupoAvaliacao);
                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagemAuxiliar(grupoAvaliacaoConsultado);
                        }
                });
        }
       
        @Override
        public String listarServidoresParaEscolhaAvaliados(String sequencialGrupo, String anoCronograma, String codigoUnidade,
                                                                                                           String nomeServidor, String matriculaServidor) {
                GrupoAvaliacao grupoAvaliacao = cenarioTestHelper.consultarGrupoAvaliacaoPorSequencial(converterStringParaLong(sequencialGrupo));
                grupoAvaliacao = VerificadorUtil.naoEstaNulo(grupoAvaliacao) ? grupoAvaliacao : criarGrupoAvaliacao(sequencialGrupo, codigoUnidade, anoCronograma);
                final ParametrosConsultarServidorAvaliacaoDisponivelParaOhGrupoAvaliacao parametros = new ParametrosConsultarServidorAvaliacaoDisponivelParaOhGrupoAvaliacao();
                parametros.setNomeServidor(nomeServidor);
                parametros.setGrupoAvaliacao(grupoAvaliacao);
                parametros.setMatriculaServidor(converterStringParaLong(matriculaServidor));
                parametros.setPrimeiroRegistro(PRIMEIRO_REGISTRO_ZERO);
                parametros.setTamanhoPagina(Integer.MAX_VALUE);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<ServidorAvaliacao> listaServidoresConsultados = servidorAvaliacaoFacade.consultarServidorAvaliacaoDisponivelParaOhGrupoAvaliacao(parametros);
                                return cenarioTestHelper.gerarMensagemServidorAvaliacaoNomeEhMatricula(listaServidoresConsultados);
                        }
                });
        }
       
        @Override
        public String consultarPessoaPorSequencial(final String sequencialPessoaFisica) {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                PessoaFisicaView pessoaFisica = pessoaFisicaViewFacade.consultarPorSequencial(converterStringParaLong(sequencialPessoaFisica));
                                return VerificadorUtil.naoEstaNulo(pessoaFisica) ? cenarioTestHelper.gerarMensagem(pessoaFisica) : DADOS_EXIBIDOS_VAZIO;
                        }
                });
        }
       
        @Override
        public String adicionarAvaliadoGrupo(final String sequencialDadoFuncional, final String numeroAnoCronograma, final String sequencialGrupoAvaliacao) {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                grupoAvaliacaoFacade.adicionarServidorAvaliacaoDoGrupo(converterStringParaLong(sequencialGrupoAvaliacao), converterStringParaLong(sequencialDadoFuncional), converterStringParaLong(numeroAnoCronograma));
                                GrupoAvaliacao grupoAvaliacao = cenarioTestHelper.consultarGrupoAvaliacaoPorSequencial(converterStringParaLong(sequencialGrupoAvaliacao));
                                return cenarioTestHelper.gerarMensagemAuxiliar(grupoAvaliacao);
                        }
                });
        }
       
        @Override
        public String remocaoAvaliadoGrupo(final String sequencialDadoFuncional, final String sequencialGrupoAvaliacao) {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                grupoAvaliacaoFacade.removerServidorAvaliacaoDoGrupo(converterStringParaLong(sequencialGrupoAvaliacao), converterStringParaLong(sequencialDadoFuncional));
                                GrupoAvaliacao grupoAvaliacao = cenarioTestHelper.consultarGrupoAvaliacaoPorSequencial(converterStringParaLong(sequencialGrupoAvaliacao));
                                return cenarioTestHelper.gerarMensagemAuxiliar(grupoAvaliacao);
                        }
                });
        }
       
        @Override
        public String excluirGrupoAvaliacao(final String sequencialGrupoAvaliacao) {
                final GrupoAvaliacao grupoAvaliacao = criarGrupoAvaliacao(sequencialGrupoAvaliacao);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                grupoAvaliacaoFacade.excluir(grupoAvaliacao);
                                GrupoAvaliacao grupoAvaliacaoConsultado = cenarioTestHelper.consultarGrupoAvaliacaoPorSequencial(converterStringParaLong(sequencialGrupoAvaliacao));
                                return VerificadorUtil.estaNulo(grupoAvaliacaoConsultado) ? "Grupo de avaliação excluído com sucesso." : null;
                        }
                });
        }

        @Override
        public String consultarCronogramaCorrente() {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                Cronograma cronograma = cronogramaFacade.consultarCronogramaCorrente();
                                return cenarioTestHelper.gerarMensagem(cronograma);
                        }
                });
        }
       
        @Override
        public String listarMatriculasAutoAvaliacao(String sequencialUsuarioLogado,     String anoCronograma) {
                PessoaFisicaView pessoa = new PessoaFisicaView();
                pessoa.setSequencialPessoa(new Long(sequencialUsuarioLogado));
                final ServidorView servidor = new ServidorViewBuilder().comPessoaFisica(pessoa).build();
                final Cronograma cronograma = new CronogramaBuilder().comNumeroAno(anoCronograma).build();
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<ServidorAvaliacao> listaServidoresConsultados = servidorAvaliacaoFacade.listarServidorAvaliacaoPorServidorEhCronograma(servidor, cronograma);
                                return cenarioTestHelper.gerarMensagemServidorAvaliacaoMatriculaUnidadeEeCargo(listaServidoresConsultados);
                        }
                });
        }
       
        @Override
        public String listarQuestaoAutoAvaliacao(String sequencialDadoFuncional, String anoCronograma) {
                final ServidorAvaliacao servidorAvaliacao = gerarServidorAvaliacao(sequencialDadoFuncional, anoCronograma);
               
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<QuestaoAvaliacaoDesempenho> listaQuestoes = avaliacaoDesempenhoFacade.listarQuestaoAutoAvaliacao(servidorAvaliacao);
                                return cenarioTestHelper.gerarMensagem(listaQuestoes.toArray(new Object[0]));
                        }
                });
        }

        @Override
        public String responderQuestaoAutoAvaliacao(String sequencialAvaliacaoDesempenho, String sequencialDadoFuncional, String anoCronograma,
                        String sequencialQuestao, String respostaMultiplaEscolha, String respostaAberta) {
                ServidorAvaliacao servidorAvaliacao = gerarServidorAvaliacao(sequencialDadoFuncional, anoCronograma);
               
                QuestaoAvaliacaoDesempenho questaoAvaliacaoDesempenho = cenarioTestHelper.consultarQuestaoAvaliacaoDesempenho(sequencialQuestao);

                final AvaliacaoDesempenho avaliacaoDesempenho = new AvaliacaoDesempenhoBuilder()
                        .comSequencial(sequencialAvaliacaoDesempenho)
                        .comServidorAvaliacao(servidorAvaliacao)
                        .comQuestaoAvaliacaoDesempenho(questaoAvaliacaoDesempenho)
                        .comTipoRespostaMultiplaEscolha(respostaMultiplaEscolha)
                        .comRespostaAberta(respostaAberta)
                        .build();

                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                avaliacaoDesempenhoFacade.responderQuestao(avaliacaoDesempenho);
                                List<QuestaoAvaliacaoDesempenho> listaQuestoes = avaliacaoDesempenhoFacade.listarQuestaoAutoAvaliacao(avaliacaoDesempenho.getServidorAvaliacao());
                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagem(listaQuestoes.toArray(new Object[0]));
                        }
                });
        }
       
        @Override
        public String listarServidoresMesmoGrupoAvaliador(String sequencialPessoaAvaliador, String anoCronograma) {
                final ParametrosConsultarServidorAvaliacaoAvaliadoPorAvaliador parametros = new ParametrosConsultarServidorAvaliacaoAvaliadoPorAvaliador();
                parametros.setSequencialPessoaFisicaAvaliador(converterStringParaLong(sequencialPessoaAvaliador));
                parametros.setNumeroAnoCronograma(converterStringParaLong(anoCronograma));
                parametros.setTamanhoPagina(Integer.MAX_VALUE);
                parametros.setPrimeiroRegistro(PRIMEIRO_REGISTRO_ZERO);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<ServidorAvaliacaoDTO> listaAvaliados = servidorAvaliacaoFacade.consultarServidorAvaliacaoAvaliadosPorAvaliador(parametros);
                                return cenarioTestHelper.gerarMensagem(listaAvaliados.toArray(new Object[0]));
                        }
                });
        }
       
        @Override
        public String listarQuestaoAvaliacao(String sequencialDadoFuncional, String anoCronograma) {
                final ServidorAvaliacao servidorAvaliacao = gerarServidorAvaliacao(sequencialDadoFuncional, anoCronograma);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<QuestaoAvaliacaoDesempenho> listaQuestoes = avaliacaoDesempenhoFacade.listarQuestaoAvaliacao(servidorAvaliacao);
                                return cenarioTestHelper.gerarMensagem(listaQuestoes.toArray(new Object[0]));
                        }
                });
        }
       
        @Override
        public String listarRevisaoNaoRespondida(String sequencialPessoaUsuario, String anoCronograma) {
                UsuarioView usuario = cenarioTestHelper.consultarUsuarioPorId(sequencialPessoaUsuario);
                Cronograma cronograma = criarCronograma(anoCronograma);
                final ParametrosConsultarRevisaoAvaliacaoNaoRespondida parametros = new ParametrosConsultarRevisaoAvaliacaoNaoRespondida();
                parametros.setCronograma(cronograma);
                parametros.setUsuario(usuario);
                parametros.setTamanhoPagina(Integer.MAX_VALUE);
                parametros.setPrimeiroRegistro(PRIMEIRO_REGISTRO_ZERO);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<RevisaoAvaliacaoDTO> revisoes = avaliacaoFacade.consultarRevisaoNaoRespondida(parametros);
                                return cenarioTestHelper.gerarMensagemConsultar(revisoes);
                        }
                });
        }
       
        @Override
        public String responderSolicitacaoRevisao(final String sequencialRevisao, String resposta, String questoesDesempenho) {
                final RevisaoAvaliacao revisaoAvaliacao = cenarioTestHelper.consultarRevisaoAvaliacao(new Long(sequencialRevisao));
                revisaoAvaliacao.setResposta(resposta);

                List<RevisaoAvaliacaoDesempenho> revisoesCriadas = criarListaRevisaoAvaliacaoDesempenho(questoesDesempenho);
                List<RevisaoAvaliacaoDesempenho> novaListaDeRevisao = new ArrayList<RevisaoAvaliacaoDesempenho>();
                for (RevisaoAvaliacaoDesempenho revisaoAvaliacaoDesempenho : revisaoAvaliacao.getRevisoesAvaliacaoDesempenho()) {
                        for (RevisaoAvaliacaoDesempenho revisaoAvaliacaoDesempenhoCriada : revisoesCriadas) {
                                if(revisaoAvaliacaoDesempenhoCriada.getReviAvaliacaoDesempenhoId().equals(revisaoAvaliacaoDesempenho.getReviAvaliacaoDesempenhoId())) {
                                        revisaoAvaliacaoDesempenho.setResposta(revisaoAvaliacaoDesempenhoCriada.getResposta());
                                }
                        }
                        novaListaDeRevisao.add(revisaoAvaliacaoDesempenho);
                }
                revisaoAvaliacao.setRevisoesAvaliacaoDesempenho(novaListaDeRevisao);

                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                avaliacaoFacade.responderSolicitacaoRevisao(revisaoAvaliacao);
                                RevisaoAvaliacao revisaoAvaliacaoConsultada = cenarioTestHelper.consultarRevisaoAvaliacao(new Long(sequencialRevisao));
                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagem(revisaoAvaliacaoConsultada);
                        }
                });
        }
       
        private List<CronogramaEtapa> criarCronogramaEtapa(Cronograma cronograma, String listaEtapas) {
                List<CronogramaEtapa> listaCronogramaEtapa = new ArrayList<CronogramaEtapa>();
                String[] etapaStringArray = {};
                if(listaEtapas != null) {
                        etapaStringArray = listaEtapas.split(";");
                }

                for (String etapaString : etapaStringArray) {
                        EtapaBuilder etapaBuilder = new EtapaBuilder();
                        CronogramaEtapaBuilder cronogramaEtapaBuilder = new CronogramaEtapaBuilder();
                        cronogramaEtapaBuilder.comCronograma(cronograma);
                        String[] camposEtapa = etapaString.split(",");
                        etapaBuilder.comCodigo(camposEtapa[0].trim());
                        etapaBuilder.comDescricao(camposEtapa[1].trim());
                        Etapa etapa = etapaBuilder.build();
                        cronogramaEtapaBuilder.comEtapa(etapa);
                        cronogramaEtapaBuilder.comDataInicialEtapa(camposEtapa[2].trim());
                        cronogramaEtapaBuilder.comDataFinalEtapa(camposEtapa[3].trim());
                        CronogramaEtapa cronogramaEtapa = cronogramaEtapaBuilder.build();
                        cronogramaEtapa.getCronogramaEtapaId().setCodigoEtapa(etapa.getCodigo());
                        cronogramaEtapa.getCronogramaEtapaId().setNumeroAno(cronograma.getNumeroAno());
                        listaCronogramaEtapa.add(cronogramaEtapa);
                }
                return listaCronogramaEtapa;
        }
       
        private Set<ServidorAvaliacao> criarServidoresAvaliacao(String listaAvaliados, GrupoAvaliacao grupoAvaliacaoBuscado) {
                Cronograma cronograma = grupoAvaliacaoBuscado.getCronograma();
                return criarServidoresAvaliacao(listaAvaliados, grupoAvaliacaoBuscado, cronograma);
        }
       
        private Set<ServidorAvaliacao> criarServidoresAvaliacao(String listaAvaliados, GrupoAvaliacao grupoAvaliacao, Cronograma cronograma) {
                Set<ServidorAvaliacao> listaServidorAvaliacao = new HashSet<ServidorAvaliacao>();
                String[] servidoresAvaliadosStringArray = {};
               
                if(listaAvaliados != null) {
                        servidoresAvaliadosStringArray = listaAvaliados.split(";");
                }

                for (String servidorAvaliacaoString : servidoresAvaliadosStringArray) {
                        String[] camposServidorAvaliacao = servidorAvaliacaoString.split(",");
                        ServidorDadoFuncionalView servidorDadoFuncional = cenarioTestHelper.consultarDadoFuncional(camposServidorAvaliacao[0].trim());
                        ServidorAvaliacao servidorAvaliacao = new ServidorAvaliacaoBuilder()
                                                                                                        .comCronograma(cronograma)
                                                                                                        .comGrupoAvaliacao(grupoAvaliacao)
                                                                                                        .comTipoEfetivoExercicio("S")
                                                                                                        .comDadoFuncional(servidorDadoFuncional)
                                                                                                        .build();

                        listaServidorAvaliacao.add(servidorAvaliacao);
                }
               
                return listaServidorAvaliacao;
        }
       
       


        @Override
        public String listarServidorParaVincularQualificacao(final String unidadesExercicio, final String cronogramaCorrente) {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<ServidorDadoFuncionalView> listaDadoFuncional = servidorFacade.listarServidorParticipanteDeGrupoDaUnidadeEhCronograma(gerarListaSequencialUnidadeExercicio(unidadesExercicio), valueLong(cronogramaCorrente), 0, 5);
                                return cenarioTestHelper.gerarMensagemServidorResumido(listaDadoFuncional);
                        }
                });
        }

        @Override
        public String listarQualificacaoServidor(String sequencialDadoFuncionalServidor, String anoCronograma) {
                final ServidorDadoFuncionalView servidorDadoFuncional = cenarioTestHelper.consultarDadoFuncional(sequencialDadoFuncionalServidor);
                final ServidorAvaliacaoId servidorAvaliacaoId = new ServidorAvaliacaoIdBuilder().comSequencialDadoFuncional(sequencialDadoFuncionalServidor).comNumeroAno(anoCronograma).build();
                final ServidorAvaliacao servidorAvaliacao = new ServidorAvaliacaoBuilder().comServidorAvaliacaoId(servidorAvaliacaoId).build();
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<QualificacaoServidorView> listaQualificacoesDisponiveis = servidorFacade.listarQualificacaoServidor(servidorDadoFuncional);
                                List<QualificacaoServidorView> listaQualificacoesUtilizadas = servidorFacade.listarQualificacaoServidorCronograma(servidorAvaliacao);
                                return cenarioTestHelper.gerarMensagemlistarQualificacaoServidor(listaQualificacoesDisponiveis, listaQualificacoesUtilizadas);
                        }
                });
        }

        @Override
        public String vincularQualificacao(final String sequencialDadoFuncionalServidor, final String numeroAnoCronograma, final String[] listaSequencialQualificacoes) {
                final ServidorDadoFuncionalView servidorDadoFuncional = criarServidorDadoFuncionalView(sequencialDadoFuncionalServidor);
                final Cronograma cronograma = criarCronograma(numeroAnoCronograma);
                final QualificacaoServidorView[] qualificacoesServidor = criarArrayQualificacaoServidorView(listaSequencialQualificacoes);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                servidorFacade.vincularQualificacao(servidorDadoFuncional, cronograma, qualificacoesServidor);
                                List<QualificacaoServidorCronograma> listaQualificacoes = cenarioTestHelper.consultarQualificacaoServidorCronograma(sequencialDadoFuncionalServidor, numeroAnoCronograma, listaSequencialQualificacoes);
                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagem(listaQualificacoes.toArray(new Object[0]));
                        }
                });
        }

        @Override
        public String solicitarRevisaoAvaliacao(String tipoAvaliacao, String solicitacao, String notaAvaliacao,
                                                                                        String sequencialDadoFuncionalServidor, String anoCronograma,
                                                                                        String questoesDesempenho) {
                ServidorAvaliacao servidorAvaliacao = criarServidorAvaliacao(sequencialDadoFuncionalServidor, anoCronograma);

                List<RevisaoAvaliacaoDesempenho> revisoesAvaliacaoDesempenho = criarListaRevisaoAvaliacaoDesempenho(questoesDesempenho);

                final RevisaoAvaliacao revisaoAvaliacao = new RevisaoAvaliacaoBuilder()
                                                                                                          .comTipoAvaliacao(tipoAvaliacao)
                                                                                                          .comSolicitacao(solicitacao)
                                                                                                          .comNota(notaAvaliacao)
                                                                                                          .comServidorAvaliacao(servidorAvaliacao)
                                                                                                          .build();

                List<RevisaoAvaliacaoDesempenho> revisoes = new ArrayList<RevisaoAvaliacaoDesempenho>();

                for (RevisaoAvaliacaoDesempenho revisaoAvaliacaoDesempenho : revisoesAvaliacaoDesempenho) {
                        RevisaoAvaliacaoDesempenhoId revisaoAvaliacaoDesempenhoId = new RevisaoAvaliacaoDesempenhoId();
                        revisaoAvaliacaoDesempenhoId.setSequencialAvaliacaoDesempenho(revisaoAvaliacaoDesempenho.getAvaliacaoDesempenho().getSequencial());

                        revisaoAvaliacaoDesempenho.setReviAvaliacaoDesempenhoId(revisaoAvaliacaoDesempenhoId);
                        revisaoAvaliacaoDesempenho.setRevisaoAvaliacao(revisaoAvaliacao);

                        revisoes.add(revisaoAvaliacaoDesempenho);
                }

                revisaoAvaliacao.setRevisoesAvaliacaoDesempenho(revisoes);

                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                avaliacaoFacade.solicitarRevisaoAvaliacao(revisaoAvaliacao);
                                RevisaoAvaliacao revisaoAvaliacaoConsultada = cenarioTestHelper.consultarRevisaoAvaliacao(revisaoAvaliacao.getSequencial());

                                return DADOS_GRAVADOS_COM_SUCESSO + cenarioTestHelper.gerarMensagem(revisaoAvaliacaoConsultada);
                        }
                });
        }

        @Override
        public String visualizarNotaAvaliacao(String sequencialServidor, String anoCronograma) {
                final List<ServidorAvaliacao> listaServidorAvaliacao = criarListaServidorAvaliacao(sequencialServidor, anoCronograma);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<Avaliacao> listaAvaliacao = new ArrayList<Avaliacao>();
                                for (ServidorAvaliacao servidorAvaliacao : listaServidorAvaliacao) {
                                        listaAvaliacao.add(avaliacaoFacade.visualizarNotaAvaliacao(servidorAvaliacao));
                                }
                                return cenarioTestHelper.gerarMensagem(listaAvaliacao.toArray());
                        }
                });
        }

        @Override
        public String consultarFaltasDoServidor(final String cronograma, final String numeroDocumentoServidor)  {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<ServidorFaltasMesAhMesDTO> listaFaltasServidores = servidorFaltaFacade.listarFaltasDoServidorMesAhMesPorDemanda(valueLong(cronograma), numeroDocumentoServidor, valueInt(PRIMEIRO_REGISTRO_0), valueInt(TAMANHO_DA_PAGINA_5));
                                String mensagemParaRetorno = cenarioTestHelper.gerarMensagem(listaFaltasServidores.toArray());
                                return ajustarMensagem(mensagemParaRetorno);
                        }
                });
        }

        @Override
        public String importarFaltasDoServidor(final String cronograma, final String nomeArquivo) {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                InputStream inputStream = null;
                                try {
                                        File planilha = new File(nomeArquivo);
                                        inputStream = new FileInputStream(planilha);
                                } catch (Exception e){}
                                        servidorFaltaFacade.importarFaltasServidor(valueLong(cronograma), inputStream, nomeArquivo);
                                        String mensagemParaRetorno = MENSAGEM_ARQUIVO_ACATADO_COM_SUCESSO + " " + cenarioTestHelper.consultarFaltasDoServidor(cronograma);
                                return ajustarMensagem(mensagemParaRetorno);
                        }
                });
        }
       
        @Override
        public String listarUnidades(String sequencialPessoaUsuario) {
                final UsuarioView usuario = cenarioTestHelper.consultarUsuarioPorId(sequencialPessoaUsuario);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<UnidadeView> listaUnidades = unidadeFacade.listarUnidadeExercicioPorPapelUsuario(usuario);
                                return cenarioTestHelper.gerarMensagem(listaUnidades.toArray());
                        }
                });
        }

        @Override
        public String emitirRelatorioQualificacao(String anoCronograma, String unidadeExercicio, String
                        sequencialGrupoAvaliacao, String matriculaServidor, String sequencialUsuarioEmissao) {
                final ParametroEmissaoRelatorioDTO parametroEmissaoRelatorio = new ParametroEmissaoRelatorioBuilder()
                                                                                                                                                                .comCronograma(anoCronograma)
                                                                                                                                                                .comUnidadeExercicio(unidadeExercicio)
                                                                                                                                                                .comGrupoAvaliacao(sequencialGrupoAvaliacao)
                                                                                                                                                                .comMatriculaServidor(matriculaServidor)
                                                                                                                                                                .comUsuario(sequencialUsuarioEmissao)
                                                                                                                                                                .build();
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                JasperPrint relatorioGerado = emissorRelatorioFacade.emitirRelatorioQualificacao(parametroEmissaoRelatorio);
                                return gerarMensagemRelatorio(relatorioGerado);
                        }
                });
        }

        @Override
        public String emitirRelatorioFaltas(String anoCronograma, String unidadeExercicio, String matriculaServidor) {
                final ParametroEmissaoRelatorioDTO parametroEmissaoRelatorio = new ParametroEmissaoRelatorioBuilder()
                                                                                        .comCronograma(anoCronograma)
                                                                                        .comUnidadeExercicio(unidadeExercicio)
                                                                                        .comMatriculaServidor(matriculaServidor)
                                                                                        .comUsuarioEmissao(gerarUsuario(SEQUENCIAL_PESSOA_LUCIANO_BARBOSA_1))
                                                                                        .build();
               
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {

                        @Override
                        public String execute() throws Exception {
                                JasperPrint relatorioGerado = emissorRelatorioFacade.emitirRelatorioFaltas(parametroEmissaoRelatorio);
                                return gerarMensagemRelatorio(relatorioGerado);
                        }

                });
        }

        @Override
        public String listarGrupoPorUnidadeExercicio(String anoCronograma,
                        String unidadeExercicio) {
                final ParametroEmissaoRelatorioDTO parametroEmissaoRelatorio = new ParametroEmissaoRelatorioBuilder()
                                                                                                                                                                .comCronograma(anoCronograma)
                                                                                                                                                                .comUnidadeExercicio(unidadeExercicio)
                                                                                                                                                                .build();
               
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                       
                        @Override
                        public String execute() throws Exception {
                                List<GrupoAvaliacao> gruposAvaliacoes = emissorRelatorioFacade.listarGrupoPorUnidadeExercicio(parametroEmissaoRelatorio);
                                return cenarioTestHelper.gerarMensagemGrupoAvaliacaoDescricao(gruposAvaliacoes);
                        }
                });
        }
       
        @Override
        public String emitirRelatorioReconsideracao(String anoCronograma,
                        String unidadeExercicio, String sequencialGrupoAvaliacao,
                        String matriculaServidor, String sequencialUsuarioEmissao) {
                final ParametroEmissaoRelatorioDTO parametroEmissaoRelatorio = new ParametroEmissaoRelatorioBuilder()
                                                                                                                                                                .comCronograma(anoCronograma)
                                                                                                                                                                .comUnidadeExercicio(unidadeExercicio)
                                                                                                                                                                .comGrupoAvaliacao(sequencialGrupoAvaliacao)
                                                                                                                                                                .comMatriculaServidor(matriculaServidor)
                                                                                                                                                                .comUsuario(sequencialUsuarioEmissao)
                                                                                                                                                                .build();
               
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {

                        @Override
                        public String execute() throws Exception {
                                JasperPrint relatorioGerado = emissorRelatorioFacade.emitirRelatorioReconsideracao(parametroEmissaoRelatorio);
                                return gerarMensagemRelatorio(relatorioGerado);
                        }
                });
        }
       
        @Override
        public String emitirRelatorioAcompanhamentoAvaliacao(String anoCronograma,
                        String unidadeExercicio, String sequencialGrupoAvaliacao,
                        String matriculaServidor, String sequencialUsuarioEmissao) {
                final ParametroEmissaoRelatorioDTO parametroEmissaoRelatorio = new ParametroEmissaoRelatorioBuilder()
                                .comCronograma(anoCronograma)
                                .comUnidadeExercicio(unidadeExercicio)
                                .comGrupoAvaliacao(sequencialGrupoAvaliacao)
                                .comMatriculaServidor(matriculaServidor)
                                .comUsuario(sequencialUsuarioEmissao)
                                .build();

                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {

                        @Override
                        public String execute() throws Exception {
                                JasperPrint relatorioGerado = emissorRelatorioFacade.emitirRelatorioAcompanhamentoAvaliacao(parametroEmissaoRelatorio);
                                return gerarMensagemRelatorio(relatorioGerado);
                        }
                });
        }
       
        @Override
        public String emitirRelatorioAvaliacaoGeral(String anoCronograma,
                        String unidadeExercicio, String sequencialGrupoAvaliacao,
                        String matriculaServidor, String sequencialUsuarioEmissao) {
                final ParametroEmissaoRelatorioDTO parametroEmissaoRelatorio = new ParametroEmissaoRelatorioBuilder()
                .comCronograma(anoCronograma)
                .comUnidadeExercicio(unidadeExercicio)
                .comGrupoAvaliacao(sequencialGrupoAvaliacao)
                .comMatriculaServidor(matriculaServidor)
                .comUsuario(sequencialUsuarioEmissao)
                .build();

                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
               
                        @Override
                        public String execute() throws Exception {
                                JasperPrint relatorioGerado = emissorRelatorioFacade.emitirRelatorioAvaliacaoGeral(parametroEmissaoRelatorio);
                                return gerarMensagemRelatorio(relatorioGerado);
                        }
                });
        }
       
        @Override
        public String emitirRelatorioObservacoes(String anoCronograma, String unidadeExercicio, String sequencialGrupoAvaliacao, String numeroMatriculaServidor) {
                final ParametroEmissaoRelatorioDTO parametroEmissaoRelatorio = new ParametroEmissaoRelatorioBuilder()
                                                                                                                                                        .comCronograma(anoCronograma)
                                                                                                                                                        .comUnidadeExercicio(unidadeExercicio)
                                                                                                                                                        .comGrupoAvaliacao(sequencialGrupoAvaliacao)
                                                                                                                                                        .comMatriculaServidor(numeroMatriculaServidor)
                                                                                                                                                        .comUsuarioEmissao(gerarUsuario(SEQUENCIAL_PESSOA_LUCIANO_BARBOSA_1))
                                                                                                                                                        .build();
               
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {

                        @Override
                        public String execute() throws Exception {
                                JasperPrint relatorioGerado = emissorRelatorioFacade.emitirRelatorioObservacoes(parametroEmissaoRelatorio);
                                return gerarMensagemRelatorio(relatorioGerado);
                        }
                       
                });
        }
       
        @Override
        public String listarQuestoesRecurso(String sequencialDadoFuncional, String numeroAnoCronograma) {
                final ServidorAvaliacao servidorAvaliacao = gerarServidorAvaliacao(sequencialDadoFuncional, numeroAnoCronograma);
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                List<QuestaoAvaliacaoDesempenho> listaQuestoes = avaliacaoDesempenhoFacade.listarQuestoesRecurso(servidorAvaliacao);
                                return cenarioTestHelper.gerarMensagem(listaQuestoes.toArray(new Object[0]));
                        }
                });
        }

        private UsuarioView gerarUsuario(String sequencialUsuarioEmissao) {
                if(VerificadorUtil.naoEstaNuloOuVazio(sequencialUsuarioEmissao)) {
                        UsuarioView usuario = new UsuarioView();
                        usuario.setSequencialPessoa(converterStringParaLong(sequencialUsuarioEmissao));
                        return usuario;
                }
                return null;
        }

        private String gerarMensagemRelatorio(JasperPrint relatorioGerado) {
                return extrairTextoDoJasperPrint(relatorioGerado);
        }

        private String extrairTextoDoJasperPrint(final JasperPrint relatorio) {
                return VerificadorLancamentoException.verificarMensagemLancamentoException(new Command() {
                        @Override
                        public String execute() throws Exception {
                                byte[] bytePdf = JasperExportManager.exportReportToPdf(relatorio);
                                PdfReader pfdReader = new PdfReader(bytePdf);

                                StringBuilder retorno = new StringBuilder("");
                                for (int i = 1; i <= pfdReader.getNumberOfPages(); i++) {
                                        retorno.append(PdfTextExtractor.getTextFromPage(new PdfReader(bytePdf), i));
                                }

                                return retorno.toString();
                        }
                });
        }
       
        private String ajustarMensagem(String mensagemParaRetorno) {
                return mensagemParaRetorno
                .replace("MES10", "Outubro").replace("MES11", "Novembro").replace("MES12", "Dezembro")
                .replace("MES1", "Janeiro").replace("MES2", "Fevereiro").replace("MES3", "Março")
                .replace("MES4", "Abril").replace("MES5", "Maio").replace("MES6", "Junho")
                .replace("MES7", "Julho").replace("MES8", "Agosto").replace("MES9", "Setembro")
                .replace("null", "0");
        }
       
        private ServidorAvaliacao criarServidorAvaliacao(String sequencialDadoFuncionalServidor, String anoCronograma){
                ServidorDadoFuncionalView servidorDadoFuncional = new ServidorDadoFuncionalViewBuilder().comSequencial(sequencialDadoFuncionalServidor).build();
                Cronograma cronograma = new CronogramaBuilder().comNumeroAno(anoCronograma).build();
                return new ServidorAvaliacaoBuilder()
                           .comCronograma(cronograma)
                           .comDadoFuncional(servidorDadoFuncional)
                           .build();
        }
       
        private ServidorAvaliacao criarServidorAvaliacao(ServidorDadoFuncionalView servidorDadoFuncional, String anoCronograma){
                Cronograma cronograma = new CronogramaBuilder().comNumeroAno(anoCronograma).build();
                return new ServidorAvaliacaoBuilder()
                                   .comCronograma(cronograma)
                                   .comDadoFuncional(servidorDadoFuncional)
                                   .build();
        }
       
        private List<ServidorAvaliacao> criarListaServidorAvaliacao(String sequencialServidor, String anoCronograma) {
                List<ServidorDadoFuncionalView> listaServidorDadoFuncional = cenarioTestHelper.consultarDadosFuncionais(sequencialServidor);
                final List<ServidorAvaliacao> listaServidorAvaliacao = new ArrayList<ServidorAvaliacao>();
                for (ServidorDadoFuncionalView servidorDadoFuncional : listaServidorDadoFuncional) {
                        listaServidorAvaliacao.add(criarServidorAvaliacao(servidorDadoFuncional, anoCronograma));
                }
                return listaServidorAvaliacao;
        }

        private void adicionarRestricaoMatriculaDadoFuncionalCasoSejaInformado(String numeroMatriculaServidor, List<Restricoes> restricoes) {
                if(VerificadorUtil.naoEstaNuloOuVazio(numeroMatriculaServidor)){
                        restricoes.add(Restricoes.igualComAlias("sd", "numeroMatricula", valueLong(numeroMatriculaServidor)));
                }
        }

        private void adicionarRestricaoNomeServidorCasoSejaInformado(String nomeServidor, List<Restricoes> restricoes) {
                if(VerificadorUtil.naoEstaNuloOuVazio(nomeServidor)){
                        restricoes.add(Restricoes.likeComAlias("sd", "servidorView.nome", nomeServidor));
                }
        }

        private void adicionarRestricaoUnidadeExercicioCasoSejaInformado(String unidadeExercicio, List<Restricoes> restricoes) {
                List<Long> sequencialUnidadesExercicio = gerarListaSequencialUnidadeExercicio(unidadeExercicio);
                if(sequencialUnidadesExercicio.size() == 1){
                        restricoes.add(Restricoes.igualComAlias("sd", "unidadeExercicio.sequencial", sequencialUnidadesExercicio.get(0)));
                }else{
                        restricoes.add(Restricoes.inComAlias("sd", "unidadeExercicio.sequencial", sequencialUnidadesExercicio));
                }
        }

        private void adicionarRestricaoCronogramaCasoSejaInformado(String anoCronograma, List<Restricoes> restricoes) {
                if(VerificadorUtil.naoEstaNuloOuVazio(anoCronograma)){
                        restricoes.add(Restricoes.igualComAlias("sv", "cronograma.numeroAno", valueLong(anoCronograma)));
                }
        }
       
        private void adicionarRestricaoEfetivoExercicioCasoSejaInformado(String tipoEfetivoExercicio, List<Restricoes> restricoes) {
                if(VerificadorUtil.naoEstaNuloOuVazio(tipoEfetivoExercicio)){
                        restricoes.add(Restricoes.igualComAlias("sv", "tipoEfetivoExercicio", tipoEfetivoExercicio));
                }
        }
       
        private List<Long> gerarListaSequencialUnidadeExercicio(String unidadeExercicio) {
                List<Long> sequencialUnidadesExercicio = new ArrayList<Long>();
                if(VerificadorUtil.naoEstaNulo(unidadeExercicio)){
                        String[] sequencias = unidadeExercicio.split(";");
                        for (String valor : sequencias) {
                                sequencialUnidadesExercicio.add(valueLong(valor));
                        }
                }
                return sequencialUnidadesExercicio;
        }

        private PessoaFisicaView criarAvaliador(String sequencialPessoaAvaliador) {
                PessoaFisicaView avaliador = null;
                if(VerificadorUtil.naoEstaNuloOuVazio(sequencialPessoaAvaliador)){
                        avaliador = new PessoaFisicaViewBuilder()
                                                        .comSequencialPessoa(sequencialPessoaAvaliador)
                                                        .build();
                }
                return avaliador;
        }

        private UnidadeView criarUnidade(String sequencialUnidade) {
                UnidadeView unidade = null;
                if(VerificadorUtil.naoEstaNuloOuVazio(sequencialUnidade)){
                        unidade = new UnidadeViewBuilder()
                                                  .comSequencial(sequencialUnidade)
                                                  .build();
                }
                return unidade;
        }
       
        private Cronograma criarCronograma(String anoCronograma) {
                Cronograma cronograma = null;
                if(VerificadorUtil.naoEstaNuloOuVazio(anoCronograma)){
                        cronograma = new CronogramaBuilder().comNumeroAno(anoCronograma).build();
                }
                return cronograma;
        }
       
        private ServidorAvaliacao gerarServidorAvaliacao(String sequencialDadoFuncional, String anoCronograma) {
                Cronograma cronograma = new CronogramaBuilder()
                                                                        .comNumeroAno(anoCronograma)
                                                                        .build();
                ServidorDadoFuncionalView dadoFuncional = new ServidorDadoFuncionalViewBuilder()
                                                                                                          .comSequencial(sequencialDadoFuncional)
                                                                                                          .build();
                return new ServidorAvaliacaoBuilder()
                                   .comCronograma(cronograma)
                                   .comDadoFuncional(dadoFuncional)
                                   .build();
        }
       
        private List<RevisaoAvaliacaoDesempenho> criarListaRevisaoAvaliacaoDesempenho(String questoesDesempenho) {
                List<RevisaoAvaliacaoDesempenho> revisoes = new ArrayList<RevisaoAvaliacaoDesempenho>();
                String[] revisaoStringArray = {};
                if(questoesDesempenho != null) {
                        revisaoStringArray = questoesDesempenho.split(";");
                }
                for (String revisaoString : revisaoStringArray) {
                        String[] camposRevisao = revisaoString.split(",");
                        String sequencialAvaliacaoDesempenho = camposRevisao[0].trim();
                        String solicitacao = null;
                        String sequencialRevisaoAvaliacao = null;
                        String resposta = null;

                        try {solicitacao = camposRevisao[1].trim();} catch (Exception e) {}
                        try {sequencialRevisaoAvaliacao = camposRevisao[2].trim();} catch (Exception e) {}
                        try {resposta = camposRevisao[3].trim();} catch (Exception e) {}

                        RevisaoAvaliacao revisaoAvaliacao = new RevisaoAvaliacaoBuilder().comSequencial(sequencialRevisaoAvaliacao).build();  
                        AvaliacaoDesempenho  avaliacaoDesempenho = new AvaliacaoDesempenhoBuilder().comSequencial(sequencialAvaliacaoDesempenho).build();

                        RevisaoAvaliacaoDesempenhoId revisaoAvaliacaoDesempenhoId = new RevisaoAvaliacaoDesempenhoId();
                        revisaoAvaliacaoDesempenhoId.setSequencialAvaliacaoDesempenho(avaliacaoDesempenho.getSequencial());
                        revisaoAvaliacaoDesempenhoId.setSequencialRevisaoAvaliacaoDesempenho(revisaoAvaliacao.getSequencial());

                        RevisaoAvaliacaoDesempenho revisaoAvaliacaoDesempenho = new RevisaoAvaliacaoDesempenhoBuilder()
                                .comAvaliacaoDesemepnho(avaliacaoDesempenho)
                                .comRevisaoAvaliacao(revisaoAvaliacao)
                                .comSolicitacao(solicitacao)
                                .comResposta(resposta)
                                .comRevisaoAvaliacaoDesempenhoId(revisaoAvaliacaoDesempenhoId)
                                .build();

                        revisoes.add(revisaoAvaliacaoDesempenho);
                }
                return revisoes;
        }
       
        private GrupoAvaliacao criarGrupoAvaliacao(String sequencialGrupo, String codigoUnidade, String anoCronograma) {
                GrupoAvaliacao grupoAvaliacao = new GrupoAvaliacaoBuilder()
                                                                                        .comCronograma(anoCronograma)
                                                                                        .comUnidade(codigoUnidade)
                                                                                        .comSequencial(sequencialGrupo)
                                                                                        .build();
                return grupoAvaliacao;
        }
       
        private GrupoAvaliacao criarGrupoAvaliacao(String sequencialGrupo) {
                GrupoAvaliacao grupoAvaliacao = null;
                if(VerificadorUtil.naoEstaNuloOuVazio(sequencialGrupo)){
                        grupoAvaliacao = new GrupoAvaliacaoBuilder()
                                                                 .comSequencial(sequencialGrupo)
                                                                 .build();
                }
                return grupoAvaliacao;
        }
       
        private ServidorDadoFuncionalView criarServidorDadoFuncionalView(String sequencialDadoFuncionalServidor) {
                ServidorDadoFuncionalView servidorDadoFuncional = null;
                if(VerificadorUtil.naoEstaNuloOuVazio(sequencialDadoFuncionalServidor)){
                        servidorDadoFuncional = new ServidorDadoFuncionalViewBuilder().comSequencial(sequencialDadoFuncionalServidor).build();
                }
                return servidorDadoFuncional;
        }
       
        private QualificacaoServidorView[] criarArrayQualificacaoServidorView(String[] listaSequencialQualificacoes) {
                QualificacaoServidorView[] qualificacoesServidor = null;
                if(VerificadorUtil.naoEstaNuloOuVazio(listaSequencialQualificacoes)){
                        qualificacoesServidor = new QualificacaoServidorView[listaSequencialQualificacoes.length];
                        for (int i = 0; i < listaSequencialQualificacoes.length; i++) {
                                qualificacoesServidor[i] = criarQualificacaoServidorView(listaSequencialQualificacoes[i]);
                        }
                }
                return qualificacoesServidor;
        }

        private QualificacaoServidorView criarQualificacaoServidorView(String sequencial) {
                QualificacaoServidorView qualificacaoServidor = null;
                if(VerificadorUtil.naoEstaNuloOuVazio(sequencial)){
                        qualificacaoServidor = new QualificacaoServidorBuilder().comSequencial(sequencial).build();
                }
                return qualificacaoServidor;
        }

}