Subversion Repositories Integrator Subversion

package br.com.ec.controller;

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

import javax.inject.Inject;
import javax.inject.Named;

import org.springframework.context.annotation.Scope;

import br.com.ec.core.generic.GenericService;
import br.com.ec.core.util.DataUtils;
import br.com.ec.core.util.VerificadorUtil;
import br.com.ec.domain.dto.AtestadoFuncionarioDTO;
import br.com.ec.domain.dto.BancoHorasDTO;
import br.com.ec.domain.dto.EnderecoDTO;
import br.com.ec.domain.dto.ExameFuncionarioDTO;
import br.com.ec.domain.dto.FuncionarioDTO;
import br.com.ec.domain.dto.FuncionarioEscalaDTO;
import br.com.ec.domain.dto.FuncionarioEventoDTO;
import br.com.ec.domain.dto.FuncionarioFeriasDTO;
import br.com.ec.domain.dto.LojaDTO;
import br.com.ec.domain.dto.PessoaDTO;
import br.com.ec.domain.dto.PessoaPapelDTO;
import br.com.ec.domain.dto.PontoDTO;
import br.com.ec.domain.dto.UsuarioDTO;
import br.com.ec.domain.dto.UsuarioLojaDTO;
import br.com.ec.domain.dto.UsuarioPerfilDTO;
import br.com.ec.domain.dto.VigenciaDTO;
import br.com.ec.domain.model.BancoHoras;
import br.com.ec.domain.model.Endereco;
import br.com.ec.domain.model.Funcionario;
import br.com.ec.domain.model.FuncionarioEvento;
import br.com.ec.domain.model.FuncionarioFerias;
import br.com.ec.domain.model.Papel;
import br.com.ec.domain.model.Ponto;
import br.com.ec.domain.model.Usuario;
import br.com.ec.domain.model.tipos.TipoFuncionarioEvento;
import br.com.ec.domain.service.AvaliacaoFuncionarioService;
import br.com.ec.domain.service.BancoHorasService;
import br.com.ec.domain.service.EnderecoService;
import br.com.ec.domain.service.FuncionarioEventoService;
import br.com.ec.domain.service.FuncionarioFeriasService;
import br.com.ec.domain.service.FuncionarioService;
import br.com.ec.domain.service.PapelService;
import br.com.ec.domain.service.PessoaPapelService;
import br.com.ec.domain.service.PessoaService;
import br.com.ec.domain.service.PontoService;
import br.com.ec.domain.service.UsuarioLojaService;
import br.com.ec.domain.service.UsuarioPerfilService;
import br.com.ec.domain.service.UsuarioService;
import br.com.ec.domain.service.VendedorService;
import br.com.ec.web.exception.VerificadorLancamentoException;
import br.com.ec.web.exception.VerificadorLancamentoException.CommandBean;
import br.com.ec.web.generic.AbstractBean;
import br.com.ec.web.message.LancadorMensagem;
import br.com.ec.web.util.TipoOperacao;

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

        private static final long serialVersionUID = 1L;
       
        private FuncionarioService funcionarioService;
        private UsuarioService usuarioService;
        private PessoaService pessoaService;
        private PapelService papelService;
        private PessoaPapelService pessoaPapelService;
        private EnderecoService enderecoService;
        private UsuarioPerfilService usuarioPerfilService;
        private UsuarioLojaService usuarioLojaService;
        private VendedorService vendedorService;
        private AvaliacaoFuncionarioService avaliacaoFuncionarioService;
        private FuncionarioFeriasService funcionarioFeriasService;
        private FuncionarioEventoService funcionarioEventoService;
        private BancoHorasService bancoHorasService;
        private PontoService pontoService;
       
        private FuncionarioDTO entidadeParaConsulta;
        private List<FuncionarioDTO> funcionarios;
       
        private FuncionarioDTO entidadeDTO;
        private PessoaPapelDTO pessoaPapelDTO;
        private Endereco endereco;
        private Usuario usuario;
        private UsuarioPerfilDTO usuarioPerfilDTO;
        private UsuarioLojaDTO usuarioLojaDTO;
        private FuncionarioFeriasDTO funcionarioFeriasDTO;
        private FuncionarioEventoDTO funcionarioEventoDTO;
        private FuncionarioEscalaDTO funcionarioEscalaDTO;
        private BancoHorasDTO bancoHorasDTO;
       
        @Inject
        public FuncionarioBean(FuncionarioService funcionarioService, UsuarioService usuarioService, PessoaService pessoaService,
                        PapelService papelService, PessoaPapelService pessoaPapelService, EnderecoService enderecoService,
                        UsuarioPerfilService usuarioPerfilService, UsuarioLojaService usuarioLojaService, VendedorService vendedorService,
                        AvaliacaoFuncionarioService avaliacaoFuncionarioService, FuncionarioFeriasService funcionarioFeriasService,
                        FuncionarioEventoService funcionarioEventoService, BancoHorasService bancoHorasService, PontoService pontoService) {
                this.funcionarioService = funcionarioService;
                this.usuarioService = usuarioService;
                this.pessoaService = pessoaService;
                this.papelService = papelService;
                this.pessoaPapelService = pessoaPapelService;
                this.enderecoService = enderecoService;
                this.usuarioPerfilService = usuarioPerfilService;
                this.usuarioLojaService = usuarioLojaService;
                this.vendedorService = vendedorService;
                this.avaliacaoFuncionarioService = avaliacaoFuncionarioService;
                this.funcionarioFeriasService = funcionarioFeriasService;
                this.funcionarioEventoService = funcionarioEventoService;
                this.bancoHorasService = bancoHorasService;
                this.pontoService = pontoService;
        }
       
        @Override
        public void preCarregamento() {
                limparEntidade();
                consultarFuncionarios();
        }

        @Override
        public void limparEntidade() {
                setEntidade(new Funcionario());
                FuncionarioDTO funcionarioParaConsulta = new FuncionarioDTO();
                funcionarioParaConsulta.setPessoaDTO(new PessoaDTO());
                setEntidadeParaConsulta(funcionarioParaConsulta);
                setEntidadeDTO(null);
                consultarFuncionarios();
        }

        @Override
        public GenericService<Funcionario> getService() {
                return funcionarioService;
        }
       
        @Override
        public Funcionario getEntidade() {
                return entidade;
        }
       
        @Override
        public void preConsultar() {
                setTipoOperacao(TipoOperacao.CONSULTAR);
        }

        @Override
        public Funcionario getId() {
                return getEntidade();
        }
       
        /*************************************************/
       
        public FuncionarioDTO getEntidadeParaConsulta() {
                return entidadeParaConsulta;
        }
        public void setEntidadeParaConsulta(FuncionarioDTO entidadeParaConsulta) {
                this.entidadeParaConsulta = entidadeParaConsulta;
        }
       
        public List<FuncionarioDTO> getFuncionarios() {
                return funcionarios;
        }
        public void setFuncionarios(List<FuncionarioDTO> funcionarios) {
                this.funcionarios = funcionarios;
        }
       
        public FuncionarioDTO getEntidadeDTO() {
                return entidadeDTO;
        }
        public void setEntidadeDTO(FuncionarioDTO entidadeDTO) {
                this.entidadeDTO = entidadeDTO;
        }
       
        public PessoaPapelDTO getPessoaPapelDTO() {
                return pessoaPapelDTO;
        }
        public void setPessoaPapelDTO(PessoaPapelDTO pessoaPapelDTO) {
                this.pessoaPapelDTO = pessoaPapelDTO;
        }
       
        public Endereco getEndereco() {
                return endereco;
        }
        public void setEndereco(Endereco endereco) {
                this.endereco = endereco;
        }
       
        public Usuario getUsuario() {
                return usuario;
        }
        public void setUsuario(Usuario usuario) {
                this.usuario = usuario;
        }
       
        public UsuarioPerfilDTO getUsuarioPerfilDTO() {
                return usuarioPerfilDTO;
        }
        public void setUsuarioPerfilDTO(UsuarioPerfilDTO usuarioPerfilDTO) {
                this.usuarioPerfilDTO = usuarioPerfilDTO;
        }
       
        public UsuarioLojaDTO getUsuarioLojaDTO() {
                return usuarioLojaDTO;
        }
        public void setUsuarioLojaDTO(UsuarioLojaDTO usuarioLojaDTO) {
                this.usuarioLojaDTO = usuarioLojaDTO;
        }
       
        public FuncionarioFeriasDTO getFuncionarioFeriasDTO() {
                return funcionarioFeriasDTO;
        }
        public void setFuncionarioFeriasDTO(FuncionarioFeriasDTO funcionarioFeriasDTO) {
                this.funcionarioFeriasDTO = funcionarioFeriasDTO;
        }
       
        public FuncionarioEventoDTO getFuncionarioEventoDTO() {
                return funcionarioEventoDTO;
        }
        public void setFuncionarioEventoDTO(FuncionarioEventoDTO funcionarioEventoDTO) {
                this.funcionarioEventoDTO = funcionarioEventoDTO;
        }

        public FuncionarioEscalaDTO getFuncionarioEscalaDTO() {
                return funcionarioEscalaDTO;
        }
        public void setFuncionarioEscalaDTO(FuncionarioEscalaDTO funcionarioEscalaDTO) {
                this.funcionarioEscalaDTO = funcionarioEscalaDTO;
        }
       
        public BancoHorasDTO getBancoHorasDTO() {
                return bancoHorasDTO;
        }
        public void setBancoHorasDTO(BancoHorasDTO bancoHorasDTO) {
                this.bancoHorasDTO = bancoHorasDTO;
        }
       
        /*************************************************/
       
        public void prepararDetalhar(FuncionarioDTO funcionarioDTO) {
                super.preDetalhar(funcionarioService.consultarPorId(new Funcionario(funcionarioDTO.getSequencialFuncionario())));
        }
       
        public void prepararAlterar(FuncionarioDTO funcionarioDTO) {
                super.preAlterar(funcionarioService.consultarPorId(new Funcionario(funcionarioDTO.getSequencialFuncionario())));
        }
       
        public void consultarFuncionarios() {
                setFuncionarios(funcionarioService.consultarFuncionarios(getEntidadeParaConsulta()));
        }
       
        public void prepararAlterarCompleto(FuncionarioDTO funcionarioDTO) {
                super.preAlterar(funcionarioService.consultarPorId(new Funcionario(funcionarioDTO.getSequencialFuncionario())));
                UsuarioDTO usuarioDTO = usuarioService.consultarPorPessoa(funcionarioDTO.getSequencialPessoaDoFuncionario());
                setEntidadeDTO(new FuncionarioDTO(getEntidade().getSequencial(), null, null));
                if (VerificadorUtil.naoEstaNulo(usuarioDTO)) {
                        getEntidadeDTO().setUsuarioDTO(usuarioDTO);
                        getEntidadeDTO().getUsuarioDTO().setPerfis(usuarioPerfilService.consultarPerfisDoUsuario(usuarioDTO.getSequencial()));
                        getEntidadeDTO().getUsuarioDTO().setLojas(usuarioLojaService.consultarLojasDoUsuario(usuarioDTO.getSequencial()));
                }
                getEntidadeDTO().setPapeisDTO(pessoaPapelService.consultarPapeisDaPessoa(getEntidade().getSequencialDaPessoa()));
                getEntidadeDTO().setEnderecosDTO(enderecoService.consultarEnderecosDaPessoa(getEntidade().getSequencialDaPessoa()));
                getEntidadeDTO().setVendedorDTO(vendedorService.consultarVendedorPorPessoa(getEntidade().getSequencialDaPessoa()));
                limparPapel();
        }
       
        public void alterarCompleto() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                pessoaService.alterar(getEntidade().getPessoa());
                                if (VerificadorUtil.naoEstaNulo(getEntidadeDTO().getUsuarioDTO())) {
                                        usuarioService.alterar(getEntidadeDTO().getUsuarioDTO());
                                }
                                vendedorService.alterar(getEntidadeDTO().getVendedorDTO());
                                alterar(getEntidade());
                        }
                });
        }
       
        public void limparPapel() {
                PessoaPapelDTO pessoaPapelDTO = new PessoaPapelDTO();
                pessoaPapelDTO.setSequencialPessoa(getEntidade().getPessoa().getSequencial());
                setPessoaPapelDTO(pessoaPapelDTO);
        }
       
        public void adicionarPapel() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                pessoaPapelService.adicionarPapel(getEntidade().getPessoa(), new Papel(getPessoaPapelDTO().getCodigoPapel()));
                                getEntidadeDTO().setPapeisDTO(pessoaPapelService.consultarPapeisDaPessoa(getPessoaPapelDTO().getSequencialPessoa()));
                                LancadorMensagem.lancarSucesso("PAPEL ADICIONADO COM SUCESSO");
                        }
                });
        }
       
        public void removerPapel(PessoaPapelDTO pessoaPapelDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                pessoaPapelService.removerPapel(pessoaPapelDTO.getSequencialPessoa(), pessoaPapelDTO.getCodigoPapel());
                                getEntidadeDTO().setPapeisDTO(pessoaPapelService.consultarPapeisDaPessoa(pessoaPapelDTO.getSequencialPessoa()));
                                LancadorMensagem.lancarSucesso("PAPEL REMOVIDO COM SUCESSO");
                        }
                });
        }
       
        public void limparEndereco() {
                Endereco endereco = new Endereco();
                endereco.setPessoa(getEntidade().getPessoa());
                endereco.setAtivo(true);
                setEndereco(endereco);
        }
       
        public void prepararAlterarEndereco(EnderecoDTO enderecoDTO) {
                setEndereco(enderecoService.consultarPorId(new Endereco(enderecoDTO.getSequencial())));
        }
       
        public void adicionarEndereco() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                enderecoService.alterar(getEndereco());
                                getEntidadeDTO().setEnderecosDTO(enderecoService.consultarEnderecosDaPessoa(getEntidade().getSequencialDaPessoa()));
                                LancadorMensagem.lancarSucesso("ENDEREÇO SALVO COM SUCESSO");
                        }
                });
        }
       
        public void removerEndereco(EnderecoDTO enderecoDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                enderecoService.removerEndereco(enderecoDTO.getSequencial());
                                getEntidadeDTO().setEnderecosDTO(enderecoService.consultarEnderecosDaPessoa(getEntidade().getSequencialDaPessoa()));
                                LancadorMensagem.lancarSucesso("ENDEREÇO REMOVIDO COM SUCESSO");
                        }
                });
        }
       
        public void limparUsuarioPerfil() {
                UsuarioPerfilDTO usuarioPerfilDTO = new UsuarioPerfilDTO();
                usuarioPerfilDTO.setSequencialUsuario(getEntidadeDTO().getUsuarioDTO().getSequencial());
                setUsuarioPerfilDTO(usuarioPerfilDTO);
        }
       
        public void adicionarUsuarioPerfil() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                usuarioPerfilService.adicionarPerfil(getUsuarioPerfilDTO().getSequencialUsuario(), getUsuarioPerfilDTO().getCodigoPerfil());
                                getEntidadeDTO().getUsuarioDTO().setPerfis(usuarioPerfilService.consultarPerfisDoUsuario(getUsuarioPerfilDTO().getSequencialUsuario()));
                                LancadorMensagem.lancarSucesso("PERFIL ADICIONADO COM SUCESSO");
                        }
                });
        }
       
        public void removerUsuarioPerfil(UsuarioPerfilDTO usuarioPerfilDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                usuarioPerfilService.removerPerfil(usuarioPerfilDTO.getSequencial());
                                getEntidadeDTO().getUsuarioDTO().setPerfis(usuarioPerfilService.consultarPerfisDoUsuario(usuarioPerfilDTO.getSequencialUsuario()));
                                LancadorMensagem.lancarSucesso("PERFIL REMOVIDO COM SUCESSO");
                        }
                });
        }
       
        public void limparUsuarioLoja() {
                UsuarioLojaDTO usuarioLojaDTO = new UsuarioLojaDTO();
                usuarioLojaDTO.setSequencialUsuario(getEntidadeDTO().getUsuarioDTO().getSequencial());
                setUsuarioLojaDTO(usuarioLojaDTO);
        }
       
        public void adicionarUsuarioLoja() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                usuarioLojaService.adicionarLoja(getUsuarioLojaDTO().getSequencialUsuario(), getUsuarioLojaDTO().getSequencialLoja());
                                getEntidadeDTO().getUsuarioDTO().setLojas(usuarioLojaService.consultarLojasDoUsuario(getUsuarioLojaDTO().getSequencialUsuario()));
                                LancadorMensagem.lancarSucesso("LOJA ADICIONADA COM SUCESSO");
                        }
                });
        }
       
        public void removerUsuarioLoja(UsuarioLojaDTO usuarioLojaDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                usuarioLojaService.removerLoja(usuarioLojaDTO.getSequencialUsuario(), usuarioLojaDTO.getSequencialLoja());
                                getEntidadeDTO().getUsuarioDTO().setLojas(usuarioLojaService.consultarLojasDoUsuario(usuarioLojaDTO.getSequencialUsuario()));
                                LancadorMensagem.lancarSucesso("LOJA REMOVIDA COM SUCESSO");
                        }
                });
        }
       
        public void consultarFerias() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                getEntidadeDTO().setFeriasDTO(funcionarioFeriasService.consultarFerias(getEntidadeDTO().getSequencialFuncionario()));
                        }
                });
        }
       
        public void selecionarFerias(FuncionarioFeriasDTO funcionarioFeriasDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                setFuncionarioFeriasDTO(funcionarioFeriasDTO);
                        }
                });
        }
       
        public void prepararFerias() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                FuncionarioFeriasDTO funcionarioFeriasDTO = new FuncionarioFeriasDTO();
                                funcionarioFeriasDTO.setFuncionarioDTO(getEntidadeDTO());
                                setFuncionarioFeriasDTO(funcionarioFeriasDTO);
                        }
                });
        }
       
        public void atualizarFerias() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                funcionarioFeriasService.alterarProvisao(getFuncionarioFeriasDTO());
                                consultarFerias();
                                LancadorMensagem.lancarSucesso("FÉRIAS ATUALIZADA COM SUCESSO!");
                        }
                });
        }
       
        public void removerFerias(FuncionarioFeriasDTO funcionarioFeriasDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                FuncionarioFerias funcionarioFerias = new FuncionarioFerias();
                                funcionarioFerias.setSequencial(funcionarioFeriasDTO.getSequencialFuncionarioFerias());
                                funcionarioFeriasService.excluir(funcionarioFerias);
                                consultarFerias();
                                LancadorMensagem.lancarSucesso("FÉRIAS REMOVIDA COM SUCESSO");
                        }
                });
        }
       
        public void consultarAvaliacoes() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                getEntidadeDTO().setAvaliacoesDTO(avaliacaoFuncionarioService.consultarAvaliacoesFuncionario(getEntidadeDTO().getSequencialFuncionario()));
                        }
                });
        }
       
        public void prepararEvento() {
                FuncionarioEventoDTO funcionarioEventoDTO = new FuncionarioEventoDTO();
                funcionarioEventoDTO.setFuncionarioDTO(getEntidadeDTO());
                setFuncionarioEventoDTO(funcionarioEventoDTO);
        }
       
        public void adicionarEvento(UsuarioDTO usuarioLogado) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                getFuncionarioEventoDTO().setUsuarioDTOCadastro(usuarioLogado);
                                funcionarioEventoService.cadastrar(getFuncionarioEventoDTO());
                                consultarEscala();
                                LancadorMensagem.lancarSucesso("EVENTO ADICIONADO COM SUCESSO");
                        }
                });
        }
       
        public void removerEvento(FuncionarioEventoDTO funcionarioEventoDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                funcionarioEventoService.excluir(new FuncionarioEvento(funcionarioEventoDTO));
                                getFuncionarioEscalaDTO().getEventosDTO().remove(funcionarioEventoDTO);
                                consultarEscala();
                                LancadorMensagem.lancarSucesso("EVENTO REMOVIDO COM SUCESSO");
                        }
                });
        }
       
        public void prepararParaAlterarEvento(FuncionarioEventoDTO funcionarioEventoDTO) {
                setFuncionarioEventoDTO(funcionarioEventoDTO);
        }
       
        public void confirmarEvento(UsuarioDTO usuarioLogado, FuncionarioEventoDTO funcionarioEventoDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                funcionarioEventoDTO.setUsuarioDTOAuditor(usuarioLogado);
                                funcionarioEventoService.alterar(new FuncionarioEvento(funcionarioEventoDTO));
                                consultarEscala();
                                LancadorMensagem.lancarSucesso("EVENTO CONFIRMADO COM SUCESSO");
                        }
                });
        }
       
        public void alterarEvento() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                FuncionarioEvento funcionarioEvento = funcionarioEventoService.consultarPorId(new FuncionarioEvento(getFuncionarioEventoDTO()));
                                funcionarioEvento.atualizarDados(getFuncionarioEventoDTO());
                                funcionarioEventoService.alterar(funcionarioEvento);
                                consultarEscala();
                                LancadorMensagem.lancarSucesso("EVENTO ALTERADO COM SUCESSO");
                        }
                });
        }
       
        public void consultarEventos(FuncionarioEscalaDTO escalaDTOSelecionada) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                setFuncionarioEscalaDTO(escalaDTOSelecionada);
                        }
                });
        }
       
        public void adicionarBancoHoras() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                bancoHorasService.cadastrar(getBancoHorasDTO());
                                consultarBancoHoras();
                                LancadorMensagem.lancarSucesso("BANCO DE HORAS ADICIONADO COM SUCESSO");
                        }
                });
        }
       
        public void removerBancoHoras(BancoHorasDTO bancoHorasDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                bancoHorasService.excluir(new BancoHoras(bancoHorasDTO));
                                getEntidadeDTO().getListaBancoHorasDTO().remove(bancoHorasDTO);
                                consultarBancoHoras();
                                LancadorMensagem.lancarSucesso("BANCO DE HORAS REMOVIDO COM SUCESSO");
                        }
                });
        }
       
        public void prepararBancoHoras() {
                BancoHorasDTO bancoHorasDTO = new BancoHorasDTO();
                bancoHorasDTO.setFuncionarioDTO(getEntidadeDTO());
                setBancoHorasDTO(bancoHorasDTO);
        }
       
        public void prepararParaAlterarBancoHoras(BancoHorasDTO bancoHorasDTO) {
                setBancoHorasDTO(bancoHorasDTO);
        }
       
        public void alterarBancoHoras() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                BancoHoras bancoHoras = bancoHorasService.consultarPorId(new BancoHoras(getBancoHorasDTO()));
                                bancoHoras.atualizarDados(getBancoHorasDTO());
                                bancoHorasService.alterar(bancoHoras);
                                consultarBancoHoras();
                                LancadorMensagem.lancarSucesso("BANCO DE HORAS ALTERADO COM SUCESSO");
                        }
                });
        }
       
        public void consultarBancoHoras() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                getEntidadeDTO().setListaBancoHorasDTO(bancoHorasService.consultarBancoHorasFuncionario(getEntidadeDTO().getSequencialFuncionario()));
                        }
                });
        }
       
        public void consultarBancoHorasDoUsuario(UsuarioDTO usuarioDTO) {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Usuario usuario = usuarioService.consultarPorId(new Usuario(usuarioDTO.getSequencial()));
                                Funcionario funcionario = funcionarioService.consultarFuncionarioPelaPessoa(usuario.getSequencialDaPessoa());
                                FuncionarioDTO funcionarioDTO = new FuncionarioDTO();
                                funcionarioDTO.setListaBancoHorasDTO(bancoHorasService.consultarBancoHorasFuncionario(funcionario.getSequencial()));
                                funcionarioDTO.setListaBancoHorasDTOAnoVigente(bancoHorasService.consultarBancoHorasFuncionarioAnoVigente(funcionario.getSequencial()));
                                setEntidadeDTO(funcionarioDTO);
                        }
                });
        }
       
        // TODO: IMPLEMENTAÇÃO PENDENTE
        public void consultarExames() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                List<ExameFuncionarioDTO> examesDTO = new ArrayList<ExameFuncionarioDTO>();
                                ExameFuncionarioDTO exameDTO = new ExameFuncionarioDTO();
                                exameDTO.setDataPrevista(DataUtils.converterStringParaData("01/05/2021"));
                                exameDTO.setTipoExame("P");
                                examesDTO.add(exameDTO);
                               
                                exameDTO = new ExameFuncionarioDTO();
                                exameDTO.setDataPrevista(DataUtils.converterStringParaData("01/05/2020"));
                                exameDTO.setDataRealizada(DataUtils.converterStringParaData("01/05/2020"));
                                exameDTO.setTipoExame("P");
                                examesDTO.add(exameDTO);
                               
                                exameDTO = new ExameFuncionarioDTO();
                                exameDTO.setDataRealizada(DataUtils.converterStringParaData("01/05/2019"));
                                exameDTO.setTipoExame("A");
                                examesDTO.add(exameDTO);
                               
                                getEntidadeDTO().setExamesDTO(examesDTO);
                        }
                });
        }
       
        // TODO: IMPLEMENTAÇÃO PENDENTE
        public void consultarAtestados() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                List<AtestadoFuncionarioDTO> atestadosDTO = new ArrayList<AtestadoFuncionarioDTO>();
                                AtestadoFuncionarioDTO atestadoDTO = new AtestadoFuncionarioDTO();
                                atestadoDTO.setDataAtestado(DataUtils.converterStringParaData("01/11/2020"));
                                atestadoDTO.setQuantidadeDias(new Long(15));
                                atestadoDTO.setCodigoCid("Y71");
                                atestadoDTO.setObservacao("COVID");
                                atestadosDTO.add(atestadoDTO);
                               
                                atestadoDTO = new AtestadoFuncionarioDTO();
                                atestadoDTO.setDataAtestado(DataUtils.converterStringParaData("01/09/2020"));
                                atestadoDTO.setQuantidadeDias(new Long(3));
                                atestadoDTO.setCodigoCid("Y59");
                                atestadoDTO.setObservacao("");
                                atestadosDTO.add(atestadoDTO);
                               
                                getEntidadeDTO().setAtestadosDTO(atestadosDTO);
                        }
                });
        }
       
        // TODO: IMPLEMENTAÇÃO PENDENTE
        public void consultarPontoEletronico() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                List<PontoDTO> pontosDTO = new ArrayList<PontoDTO>();
                                PontoDTO pontoDTO = new PontoDTO();
                                LojaDTO lojaDTO = new LojaDTO();
                                lojaDTO.setDescricao("QUIOSQUE BIG GRUTA");
                                pontoDTO.setLojaDTO(lojaDTO);
                               
                                PessoaDTO pessoaDTO = new PessoaDTO();
                                pessoaDTO.setNome(getEntidadeDTO().getNomeDaPessoa());
                                pontoDTO.setPessoaDTO(pessoaDTO);
                               
                                pontoDTO.setDataPonto(DataUtils.converterStringParaData("13/08/2021"));
                                pontoDTO.setDataHoraPontoInicio(DataUtils.converterStringParaDataComHorario("13/08/2021 16:00:00"));
                                pontoDTO.setDataHoraPontoFim(DataUtils.converterStringParaDataComHorario("13/08/2021 16:00:00"));
                                pontoDTO.setDataHoraIntervaloInicio(DataUtils.converterStringParaDataComHorario("13/08/2021 16:00:00"));
                                pontoDTO.setDataHoraIntervaloFim(DataUtils.converterStringParaDataComHorario("13/08/2021 16:00:00"));
                                pontoDTO.setObservacao("");
                                pontosDTO.add(pontoDTO);
                               
                                getEntidadeDTO().setPontosDTO(pontosDTO);
                        }
                });
        }
       
        /*
        public String retornarTipoOcorrenciaEscala(Date dataPonto, List<Ponto> pontos) {
                String tipoOcorrenciaEscala = TipoOcorrenciaEscala.SEM_PONTO.getValor();
                for (Ponto ponto : pontos) {
                        if (DataUtils.datasIguais(ponto.getDataPonto(), dataPonto)) {
                                if (ponto.getPontoCompleto()) {
                                        return TipoOcorrenciaEscala.PONTO_COMPLETO.getValor();
                                } else {
                                        return TipoOcorrenciaEscala.PONTO_INCOMPLETO.getValor();
                                }
                        }
                }
                return tipoOcorrenciaEscala;
        }
        */
       
        // TODO: IMPLEMENTAÇÃO PENDENTE
        public void consultarEscala() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                VigenciaDTO vigenciaSelecionada = getEntidadeDTO().getVigenciaEscalaDTO();
                                Date dataPonto = vigenciaSelecionada.getDataInicio();
                                Date dataInicio = vigenciaSelecionada.getDataInicio();
                                Date dataFim = vigenciaSelecionada.getDataFim();
                                List<FuncionarioEscalaDTO> escalasDTO = new ArrayList<FuncionarioEscalaDTO>();
                                FuncionarioEscalaDTO escalaDTO = null;
                                List<Ponto> pontos = pontoService.consultarPontosEletronicos(getEntidadeDTO().getVigenciaEscalaDTO(), getEntidade().getSequencialDaPessoa());
                                List<FuncionarioEventoDTO> eventos = funcionarioEventoService.consultarEventos(getEntidadeDTO().getVigenciaEscalaDTO(), getEntidade().getSequencial());
                                while (DataUtils.dataEstaEntrePeriodos(dataPonto, dataInicio, dataFim) ||
                                                DataUtils.datasIguais(dataPonto, dataInicio) ||
                                                DataUtils.datasIguais(dataPonto, dataFim)) {
                                        escalaDTO = new FuncionarioEscalaDTO();
                                        escalaDTO.atualizarDadosEscala(dataPonto, pontos);
                                        escalaDTO.atualizarDadosEventos(dataPonto, eventos);
                                        escalasDTO.add(escalaDTO);
                                        dataPonto = DataUtils.acrescentarDias(dataPonto, 1);
                                }
                                getEntidadeDTO().setListaFuncionarioEscalaDTO(escalasDTO);
                        }
                });
        }
       
}