Пример #1
0
  /**
   * Exclui um registro
   *
   * @param objTalento POJO representando o objeto a ser incluído
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public void excluir(Talento objTalento) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e inclui registro
    AtributoTalentoValoradoDAO objAtributoTalentoValoradoDAO = new AtributoTalentoValoradoDAO();
    TalentoDAO objTalentoDAO = new TalentoDAO();
    try {
      // Inicia transação
      DAO.iniciarTransacao();

      // Exclui valorações
      objAtributoTalentoValoradoDAO.excluirPorTalento(objTalento);

      // Exclui
      objTalentoDAO.excluir(objTalento);

      // Realiza transação
      DAO.realizarTransacao();
    } catch (Exception daoe) {
      DAO.desfazerTransacao();
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
  }
Пример #2
0
  /**
   * Obtém os registros da pessoa desejada, de determinada categoria de talento e de determinada
   * página
   *
   * @param objPessoa Pessoa desejada
   * @param objCategoriaTalento Categoria de talento desejada
   * @param int Número da página a ser mostrada
   * @param int Quantidade de registros
   * @return List Contendo os POJOs representando os registro obtidos
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public List obterPorPessoaCategoriaTalentoPorPagina(
      Pessoa objPessoa,
      CategoriaTalento objCategoriaTalento,
      int intNumeroPagina,
      int intMaximoPagina)
      throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém os registros da página
    TalentoDAO objTalentoDAO = new TalentoDAO();
    List lstRetorno = new ArrayList();
    try {
      List lstTalentos =
          objTalentoDAO.obterPorPessoaCategoriaTalentoPorPagina(
              objPessoa, objCategoriaTalento, intNumeroPagina, intMaximoPagina);
      Iterator itrTalentos = lstTalentos.iterator();
      while (itrTalentos.hasNext()) {
        Talento objTalento = (Talento) itrTalentos.next();
        TalentoVisualizacao objTalentoVisualizacao = new TalentoVisualizacao();
        Copia.criar(objTalento, objTalentoVisualizacao);
        objTalentoVisualizacao.setDescricao(obterDescricao(objTalento));
        lstRetorno.add(objTalentoVisualizacao);
      }

    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return lstRetorno;
  }
Пример #3
0
  /**
   * Obtém a hierarquia superior da opção desejada (incluindo ela)
   *
   * @param objAtributoTalentoOpcao Opção de atributo de talento desejada
   * @return List Contendo os registros
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public List obterAtributoTalentoOpcaoHierarquiaSuperior(
      AtributoTalentoOpcao objAtributoTalentoOpcao) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    AtributoTalentoOpcaoDAO objAtributoTalentoOpcaoDAO = new AtributoTalentoOpcaoDAO();
    AtributoTalentoOpcaoFacade objAtributoTalentoOpcaoFacade = new AtributoTalentoOpcaoFacade();
    List lstAtributoTalentoOpcoesHierarquiaSuperior = new ArrayList();
    try {
      objAtributoTalentoOpcao =
          (AtributoTalentoOpcao)
              objAtributoTalentoOpcaoDAO.obterPelaChave(
                  String.valueOf(objAtributoTalentoOpcao.getIdentificador()));
      lstAtributoTalentoOpcoesHierarquiaSuperior =
          objAtributoTalentoOpcaoFacade.obterHierarquiaSuperior(objAtributoTalentoOpcao);
      lstAtributoTalentoOpcoesHierarquiaSuperior.add(objAtributoTalentoOpcao);

    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return lstAtributoTalentoOpcoesHierarquiaSuperior;
  }
Пример #4
0
  /**
   * Inclui um registro
   *
   * @param objTalento POJO representando o objeto a ser incluído
   * @param lstAtributosTalentoValoros List contendo as valorações do talento a serem incluídas
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   * @return retorna a chave do objeto que foi incluido
   */
  public String incluir(Talento objTalento, List lstAtributosTalentoValorados) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e inclui registro
    TalentoDAO objTalentoDAO = new TalentoDAO();
    CategoriaTalentoDAO objCategoriaTalentoDAO = new CategoriaTalentoDAO();
    String strChave = null;
    try {
      // Não é permitido que a pessoa tenha mais de uma categoria cadastrada se ela for perfil
      CategoriaTalento objCategoriaTalento =
          (CategoriaTalento)
              objCategoriaTalentoDAO.obterPelaChave(
                  String.valueOf(objTalento.getCategoriaTalento().getIdentificador()));
      if ("S".equals(objCategoriaTalento.getIndicativoUnicidade())) {
        if (objTalentoDAO.verificarExistenciaPorPessoaCategoriaTalento(
            objTalento.getPessoa(), objTalento.getCategoriaTalento())) {
          throw new NegocioException(
              "Não é possível inserir mais de um talento se a categoria " + "em questão é perfil");
        }
      }

      // Verifica as valorações obrigatórios
      verificarValoracoesObrigatorias(
          objTalento.getCategoriaTalento(), lstAtributosTalentoValorados);

      // Inicia transação
      DAO.iniciarTransacao();

      // Preenche dados de talento
      objTalento.setDataLancamento(DataNova.formatarCalendar(DataNova.obterDataAtual()));

      // Inclui talento
      strChave = objTalentoDAO.incluir(objTalento);
      objTalento.setIdentificador(Integer.valueOf(strChave));

      // Inclui valorações
      incluirValoracoes(objTalento, lstAtributosTalentoValorados);

      // Realiza transação
      DAO.realizarTransacao();

    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    // Retorna chave
    return strChave;
  }
Пример #5
0
  /**
   * Obtém uma categoria de talento a partir da chave
   *
   * @param strChave Chave do registro a ser obtido
   * @return CategoriaTalento POJO representando o registro obtido
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public CategoriaTalento obterCategoriaTalentoPelaChave(String strChave) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    CategoriaTalentoDAO objCategoriaTalentoDAO = new CategoriaTalentoDAO();
    CategoriaTalento objCategoriaTalento = null;
    try {
      objCategoriaTalento = (CategoriaTalento) objCategoriaTalentoDAO.obterPelaChave(strChave);
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return objCategoriaTalento;
  }
Пример #6
0
  /**
   * Obtém as categorias de talento disponíveis para o usuário desejado
   *
   * @param objPessoa Pessoa a buscar os talentos
   * @return List Contendo os POJOs representando os registro obtidos
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public List obterCategoriasTalento(Pessoa objPessoa) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém os registros
    CategoriaTalentoDAO objCategoriaTalentoDAO = new CategoriaTalentoDAO();
    List lstRetorno = null;
    try {
      lstRetorno = objCategoriaTalentoDAO.obterTodosPorGrupo(objPessoa.getGrupo());
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return lstRetorno;
  }
Пример #7
0
  /**
   * Obtém o total de registros por pessoa
   *
   * @param objPessoa Pessoa desejada
   * @return int Contendo o total
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public int obterTotalRegistrosPorPessoa(Pessoa objPessoa) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém os registros da página
    TalentoDAO objTalentoDAO = new TalentoDAO();
    int intTotalRegistros = 0;
    try {
      intTotalRegistros = objTalentoDAO.obterTotalRegistrosPorPessoa(objPessoa);
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return intTotalRegistros;
  }
Пример #8
0
  /**
   * Obtém todos os registros
   *
   * @return List Contendo os POJOs representando os registro obtidos
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public List obterTodos() throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém todos os registros
    TalentoDAO objTalentoDAO = new TalentoDAO();
    List lstRetorno = null;
    try {
      lstRetorno = objTalentoDAO.obterTodos();
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return lstRetorno;
  }
Пример #9
0
  /**
   * Obtém as opções de um determinado atributo talento
   *
   * @param objAtributoTalento Atributo de talento desejado
   * @return List Contendo os registros
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public List obterOpcoesAtributoTalento(AtributoTalento objAtributoTalento) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO
    AtributoTalentoOpcaoDAO objAtributoTalentoOpcaoDAO = new AtributoTalentoOpcaoDAO();
    List lstAtributoTalentoOpcoes = null;
    try {
      lstAtributoTalentoOpcoes =
          objAtributoTalentoOpcaoDAO.obterPorAtributoTalento(objAtributoTalento);
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return lstAtributoTalentoOpcoes;
  }
Пример #10
0
  /**
   * Obtém uma opção de talento a partir da chave
   *
   * @param strChave Chave do registro a ser obtido
   * @return AtributoTalentoOpcao POJO representando o registro obtido
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public AtributoTalentoOpcao obterAtributoTalentoOpcaoPelaChave(String strChave)
      throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    AtributoTalentoOpcaoDAO objAtributoTalentoOpcaoDAO = new AtributoTalentoOpcaoDAO();
    AtributoTalentoOpcao objAtributoTalentoOpcao = null;
    try {
      objAtributoTalentoOpcao =
          (AtributoTalentoOpcao) objAtributoTalentoOpcaoDAO.obterPelaChave(strChave);
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return objAtributoTalentoOpcao;
  }
Пример #11
0
  /**
   * Obtém as opções filhas de determinada opção pai
   *
   * @param objAtributoTalento Atributo de talento desejado
   * @return List Contendo os registros
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public List obterOpcoesPeloPai(AtributoTalentoOpcao objAtributoTalentoOpcaoPai)
      throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    AtributoTalentoOpcaoDAO objAtributoTalentoOpcaoDAO = new AtributoTalentoOpcaoDAO();
    List lstAtributoTalentoOpcoes = null;
    try {
      lstAtributoTalentoOpcoes =
          objAtributoTalentoOpcaoDAO.obterPeloPai(objAtributoTalentoOpcaoPai);
    } catch (DAOException daoe) {
      throw new CDException(daoe);
    } finally {
      DAO.desconectar();
    }
    return lstAtributoTalentoOpcoes;
  }
Пример #12
0
  /**
   * Obtém as valorações do talento especificado
   *
   * @param objTalento Talento desejado
   * @return List Contendo os registros
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public List obterValoracoesPorTalento(Talento objTalento) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    AtributoTalentoValoradoDAO objAtributoTalentoValoradoDAO = new AtributoTalentoValoradoDAO();
    List lstAtributosTalentoValorados = null;
    try {
      lstAtributosTalentoValorados = objAtributoTalentoValoradoDAO.obterPeloTalento(objTalento);
      objAtributoTalentoValoradoDAO.inicializarCategoriaAtributoTalento(
          lstAtributosTalentoValorados);
      objAtributoTalentoValoradoDAO.inicializarAtributoTalentoOpcao(lstAtributosTalentoValorados);
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return lstAtributosTalentoValorados;
  }
Пример #13
0
  /**
   * Obtém um registro de pessoa a partir da chave
   *
   * @param strChave Chave do registro a ser obtido
   * @return Pessoa POJO representando o registro obtido
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public Pessoa obterPessoaPelaChave(String strChave) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    PessoaDAO objPessoaDAO = new PessoaDAO();
    Pessoa objPessoa = null;
    try {
      objPessoa = (Pessoa) objPessoaDAO.obterPelaChave(strChave);
      if (objPessoa != null) {
        objPessoaDAO.inicializarGrupo(objPessoa);
      }
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return objPessoa;
  }
Пример #14
0
  /**
   * Obtém categoria/atributo de acordo com a categoria e o atributo passados
   *
   * @param objCategoriaTalento Categoria de talento a ser consultada
   * @param objAtributoTalento Atributo de talento a ser consultado
   * @return CategoriaAtributoTalento Contendo a categoria/atributo
   * @throws DAOException se ocorrer algum erro relacionado com o acesso a banco de dados
   */
  public CategoriaAtributoTalento obterCategoriaAtributoTalentoPorCategoriaTalentoAtributoTalento(
      CategoriaTalento objCategoriaTalento, AtributoTalento objAtributoTalento) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém todos os registros
    CategoriaAtributoTalentoDAO objCategoriaAtributoTalentoDAO = new CategoriaAtributoTalentoDAO();
    CategoriaAtributoTalento objCategoriaAtributoTalento = null;
    try {
      objCategoriaAtributoTalento =
          objCategoriaAtributoTalentoDAO.obterPorCategoriaTalentoAtributoTalento(
              objCategoriaTalento, objAtributoTalento);
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return objCategoriaAtributoTalento;
  }
Пример #15
0
  /**
   * Obtém os relacionamentos categoria/atributo que são filhos da categoria/atributo informado
   *
   * @param objCategoriaAtributoTalento Categoria/atributo de talento desejado
   * @return List Contendo os registros
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public List obterCategoriaAtributosTalentoFilhos(
      CategoriaAtributoTalento objCategoriaAtributoTalento) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    CategoriaAtributoTalentoDAO objCategoriaAtributoTalentoDAO = new CategoriaAtributoTalentoDAO();
    List lstCategoriaAtributosTalentoFilhos = null;
    try {
      lstCategoriaAtributosTalentoFilhos =
          objCategoriaAtributoTalentoDAO.obterTodosOsFilhos(objCategoriaAtributoTalento);
      objCategoriaAtributoTalentoDAO.inicializarAtributoTalento(lstCategoriaAtributosTalentoFilhos);
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return lstCategoriaAtributosTalentoFilhos;
  }
Пример #16
0
  /**
   * Obtém a hierarquia inferior da categoria/atributo desejada
   *
   * @param objCategoriaAtributoTalento Categoria/atributo de atributo de talento desejada
   * @return List Contendo os registros
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public List obterCategoriaAtributoTalentoHierarquiaInferior(
      CategoriaAtributoTalento objCategoriaAtributoTalento) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    CategoriaAtributoTalentoFacade objCategoriaAtributoTalentoFacade =
        new CategoriaAtributoTalentoFacade();
    List lstCategoriaAtributoTalentoHierarquiaInferior = new ArrayList();
    try {
      lstCategoriaAtributoTalentoHierarquiaInferior =
          objCategoriaAtributoTalentoFacade.obterHierarquiaInferior(objCategoriaAtributoTalento);
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return lstCategoriaAtributoTalentoHierarquiaInferior;
  }
Пример #17
0
  /**
   * Verifica se determinado atributo de talento têm filhos na relação categoria/atributo
   *
   * @param objCategoriaAtributoTalento Categoria/atributo de talento desejado
   * @return boolean Com a verificação
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public boolean verificarExistenciaCategoriaAtributosFilhos(
      CategoriaAtributoTalento objCategoriaAtributoTalento) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    CategoriaAtributoTalentoDAO objCategoriaAtributoTalentoDAO = new CategoriaAtributoTalentoDAO();
    boolean blnExistenciaFilhos = false;
    try {
      blnExistenciaFilhos =
          objCategoriaAtributoTalentoDAO.verificarExistenciaCategoriaAtributosTalentoFilhos(
              objCategoriaAtributoTalento);
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return blnExistenciaFilhos;
  }
Пример #18
0
  /**
   * Obtém um registro a partir da chave, incluindo também a descrição
   *
   * @param strChave Chave do registro a ser obtido
   * @return TalentoVisualizacao POJO (extendido) representando o registro obtido
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public TalentoVisualizacao obterPelaChaveComDescricao(String strChave) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    TalentoDAO objTalentoDAO = new TalentoDAO();
    Talento objTalento = null;
    TalentoVisualizacao objTalentoVisualizacao = null;
    try {
      objTalento = (Talento) objTalentoDAO.obterPelaChave(strChave);
      objTalentoVisualizacao = new TalentoVisualizacao();
      Copia.criar(objTalento, objTalentoVisualizacao);
      objTalentoVisualizacao.setDescricao(obterDescricao(objTalento));
    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return objTalentoVisualizacao;
  }
Пример #19
0
  /**
   * Obtém a descrição de determinado talento
   *
   * @param objTalento Talento a ser descrito
   * @return String Contendo a descrição
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public String obterDescricao(Talento objTalento) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e obtém o registro pela chave
    AtributoTalentoValoradoDAO objAtributoTalentoValoradoDAO = new AtributoTalentoValoradoDAO();
    String strDescricao = "";
    try {
      if ("S".equals(objTalento.getCategoriaTalento().getIndicativoUnicidade())) {
        strDescricao = objTalento.getCategoriaTalento().getNome();
      } else {
        List lstRetorno = objAtributoTalentoValoradoDAO.obterPeloTalento(objTalento);
        Iterator itrRetorno = lstRetorno.iterator();
        while (itrRetorno.hasNext()) {
          AtributoTalentoValorado objAtributoTalentoValorado =
              (AtributoTalentoValorado) itrRetorno.next();
          if ("S"
              .equals(
                  objAtributoTalentoValorado
                      .getCategoriaAtributoTalento()
                      .getFormacaoDescricao())) {
            strDescricao += objAtributoTalentoValorado.getValoracao() + "/";
          }
        }
        if ("".equals(strDescricao)) {
          strDescricao = objTalento.getCategoriaTalento().getNome();
        } else {
          strDescricao = strDescricao.substring(0, strDescricao.length() - 1);
        }
      }

    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
    return strDescricao;
  }
Пример #20
0
  /**
   * Altera um registro
   *
   * @param objTalento POJO representando o objeto a ser incluído
   * @throws CDException se ocorrer algum erro relacionado ao negócio
   */
  public void alterar(Talento objTalento, List lstAtributosTalentoValorados) throws CDException {
    if (log.isDebugEnabled()) {
      log.debug("Entrada no metodo");
    }

    // Instancia DAO e altera registro
    TalentoDAO objTalentoDAO = new TalentoDAO();
    AtributoTalentoValoradoDAO objAtributoTalentoValoradoDAO = new AtributoTalentoValoradoDAO();
    try {
      // Verifica as valorações obrigatórios
      verificarValoracoesObrigatorias(
          objTalento.getCategoriaTalento(), lstAtributosTalentoValorados);

      // Inicia transação
      DAO.iniciarTransacao();

      // Preenche dados de talento
      objTalento.setDataLancamento(DataNova.formatarCalendar(DataNova.obterDataAtual()));

      // Exclui valorações anteriores
      objAtributoTalentoValoradoDAO.excluirPorTalento(objTalento);

      // Reinclui valorações
      incluirValoracoes(objTalento, lstAtributosTalentoValorados);

      // Altera
      objTalentoDAO.alterar(objTalento);

      // Realiza transação
      DAO.realizarTransacao();
    } catch (Exception daoe) {
      DAO.desfazerTransacao();
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
  }
Пример #21
0
  private void incluirValoracoes(Talento objTalento, List lstAtributosTalentoValorados)
      throws CDException {
    // Declarações
    CategoriaAtributoTalentoDAO objCategoriaAtributoTalentoDAO = new CategoriaAtributoTalentoDAO();
    AtributoTalentoOpcaoDAO objAtributoTalentoOpcaoDAO = new AtributoTalentoOpcaoDAO();
    AtributoTalentoValoradoDAO objAtributoTalentoValoradoDAO = new AtributoTalentoValoradoDAO();

    try {

      // Inclui valorações
      Iterator itrAtributosTalentoValorados = lstAtributosTalentoValorados.iterator();
      while (itrAtributosTalentoValorados.hasNext()) {
        // Obtém valoração
        AtributoTalentoValorado objAtributoTalentoValorado =
            (AtributoTalentoValorado) itrAtributosTalentoValorados.next();

        // INICIO - Lucene no Banco de Talentos
        if (objAtributoTalentoValorado.getValoracao() == null
            || "".equals(objAtributoTalentoValorado.getValoracao())) {
          continue;
        }
        // FIM - Lucene no Banco de Talentos

        // Seta talento
        objAtributoTalentoValorado.setTalento(objTalento);

        // Obtém categoria/atributo relacionado
        CategoriaAtributoTalento objCategoriaAtributoTalento =
            (CategoriaAtributoTalento)
                objCategoriaAtributoTalentoDAO.obterPelaChave(
                    String.valueOf(
                        objAtributoTalentoValorado
                            .getCategoriaAtributoTalento()
                            .getIdentificador()));

        // INICIO - Lucene no Banco de Talentos
        objAtributoTalentoValorado.setCategoriaAtributoTalento(objCategoriaAtributoTalento);
        // Obtem o AtributoTalento correspondente a CategoriaAtributoTalento porque sera necessario
        // usar no Lucene depois
        // objCategoriaAtributoTalentoDAO.inicializarAtributoTalento(objAtributoTalentoValorado.getCategoriaAtributoTalento());
        // O codigo acima tambem nao funcionou, mas neste caso pode ser porque nem mesmo o id de
        // AtributoTalento estava na classe CategoriaAtributoTalento
        // Para resolver alterei o mapeamento e tornei o atributo AtributoTalento não lazy na classe
        // CategoriaAtributoTalento
        // FIM - Lucene no Banco de Talentos

        // Verifica o nome do atributo de talento
        String strNomeCampo;
        if (objCategoriaAtributoTalento.getApelido() == null
            || "".equals(objCategoriaAtributoTalento.getApelido())) {
          strNomeCampo = objCategoriaAtributoTalento.getAtributoTalento().getNome();
        } else {
          // TODO Analisar se deve prevalecer o código do Christian que está abaixo
          // strNomeCampo = objAtributoTalentoValorado.getCategoriaAtributoTalento().getApelido();

          strNomeCampo = objCategoriaAtributoTalento.getApelido();
        }

        // Trata atributo virtual
        if (GerenciadorAtributoVirtual.isAtributoVirtual(
            objCategoriaAtributoTalento.getAtributoTalento().getNome())) {
          // se for um atributo virtual já tem que ir direto para inclusão
        }
        // Verifica se a categoria/atributo recebido tem opções, e se tiver, cria o objeto
        // AtributoTalentoOpcao
        // e o relaciona, se não tiver, valida o tipo de dado
        else if ("U"
                .equals(
                    objCategoriaAtributoTalento
                        .getAtributoTalento()
                        .getTipoHTML()
                        .getMultiplicidade())
            || "M"
                .equals(
                    objCategoriaAtributoTalento
                        .getAtributoTalento()
                        .getTipoHTML()
                        .getMultiplicidade())) {
          if (objAtributoTalentoValorado.getValoracao() != null
              && !"".equals(objAtributoTalentoValorado.getValoracao())) {
            AtributoTalentoOpcao objAtributoTalentoOpcao = new AtributoTalentoOpcao();
            objAtributoTalentoOpcao.setIdentificador(
                Integer.valueOf(objAtributoTalentoValorado.getValoracao()));
            objAtributoTalentoOpcao =
                (AtributoTalentoOpcao)
                    objAtributoTalentoOpcaoDAO.obterPelaChave(
                        String.valueOf(objAtributoTalentoOpcao.getIdentificador()));
            objAtributoTalentoValorado.setAtributoTalentoOpcao(objAtributoTalentoOpcao);
            objAtributoTalentoValorado.setValoracao(objAtributoTalentoOpcao.getDescricao());
          }
        } else {
          // Valida o tipo de dado
          if ("T".equals(objCategoriaAtributoTalento.getAtributoTalento().getTipoDado())) {
            if (objCategoriaAtributoTalento.getAtributoTalento().getMascara() != null
                && !"".equals(objCategoriaAtributoTalento.getAtributoTalento().getMascara())
                && objAtributoTalentoValorado.getValoracao() != null
                && !"".equals(objAtributoTalentoValorado.getValoracao())) {
              if (!ExpressaoRegular.validar(
                  objCategoriaAtributoTalento.getAtributoTalento().getMascara(),
                  objAtributoTalentoValorado.getValoracao())) {
                throw new CDException("O atributo " + strNomeCampo + " deve ser numérico");
              }
            }
          }
          if ("N".equals(objCategoriaAtributoTalento.getAtributoTalento().getTipoDado())) {
            if (objAtributoTalentoValorado.getValoracao() != null
                && !"".equals(objAtributoTalentoValorado.getValoracao())
                && !Numero.validarNumero(objAtributoTalentoValorado.getValoracao())) {
              throw new CDException("O atributo " + strNomeCampo + " deve ser numérico");
            }
          }
          if ("D".equals(objCategoriaAtributoTalento.getAtributoTalento().getTipoDado())) {
            if (objAtributoTalentoValorado.getValoracao() != null
                && !"".equals(objAtributoTalentoValorado.getValoracao())
                && (objAtributoTalentoValorado.getValoracao().trim().length() != 10
                    || !DataNova.validarData(objAtributoTalentoValorado.getValoracao()))) {
              throw new CDException("O atributo " + strNomeCampo + " deve ser uma data válida");
            }
          }
        }

        // Inclui valoração
        objAtributoTalentoValoradoDAO.incluir(objAtributoTalentoValorado);

        // INICIO - Lucene no Banco de Talentos
        // Trata insercao no Lucene
        // Se der algum problema, a transacao no banco vai continuar e um log com o
        // erro no Lucene será gerado
        IndexaTalento idx = null;
        try {
          // Tenta excluir campos do tipo "D"ata e "N"umero
          // Nem sempre o tipo de dado esta preenchido
          if (objAtributoTalentoValorado
                      .getCategoriaAtributoTalento()
                      .getAtributoTalento()
                      .getTipoDado()
                  == null
              || "T"
                  .equals(
                      objAtributoTalentoValorado
                          .getCategoriaAtributoTalento()
                          .getAtributoTalento()
                          .getTipoDado())) {
            // Incluir no Lucene
            idx = IndexaTalento.getInstance();
            idx.addTalento(
                objTalento.getPessoa().getIdentificador().toString(),
                objAtributoTalentoValorado.getValoracao());
          }
        } catch (IOException e) {
          if (log.isErrorEnabled()) {
            log.error(e);
          }
        } finally {
          if (idx != null) {
            try {
              idx.close();
            } catch (Exception e) {
            }
          }
        }
        // FIM - Lucene no Banco de Talentos

      }
    } catch (Exception daoe) {
      DAO.desfazerTransacao();
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
  }
Пример #22
0
  private void verificarValoracoesObrigatorias(
      CategoriaTalento objCategoriaTalento, List lstAtributosTalentoValorados) throws CDException {
    try {
      // Declarações
      CategoriaAtributoTalentoDAO objCategoriaAtributoTalentoDAO =
          new CategoriaAtributoTalentoDAO();

      // Obtém categoria/atributos da categoria
      List lstCategoriaAtributosTalento =
          objCategoriaAtributoTalentoDAO.obterPorCategoriaTalento(objCategoriaTalento);

      // Verifica os atributos de talento obrigatórios
      Iterator itrCategoriaAtributosTalento = lstCategoriaAtributosTalento.iterator();
      while (itrCategoriaAtributosTalento.hasNext()) {
        // Obtém categoria/atributo atual e marca a presença como falsa
        CategoriaAtributoTalento objCategoriaAtributoTalento =
            (CategoriaAtributoTalento) itrCategoriaAtributosTalento.next();
        boolean blnPresente = false;
        boolean blnPreenchido = false;

        // Verifica o nome do atributo de talento
        String strNomeCampo;
        if (objCategoriaAtributoTalento.getApelido() == null
            || "".equals(objCategoriaAtributoTalento.getApelido())) {
          strNomeCampo = objCategoriaAtributoTalento.getAtributoTalento().getNome();
        } else {
          strNomeCampo = objCategoriaAtributoTalento.getApelido();
        }

        // Verifica se o atributo está presente e foi preenchido
        Iterator itrAtributosTalentoValorados = lstAtributosTalentoValorados.iterator();
        while (itrAtributosTalentoValorados.hasNext()) {
          AtributoTalentoValorado objAtributoTalentoValorado =
              (AtributoTalentoValorado) itrAtributosTalentoValorados.next();
          if (objCategoriaAtributoTalento
              .getIdentificador()
              .equals(
                  objAtributoTalentoValorado.getCategoriaAtributoTalento().getIdentificador())) {
            blnPresente = true;
            if (objAtributoTalentoValorado.getValoracao() != null
                && !"".equals(objAtributoTalentoValorado.getValoracao())) {
              blnPreenchido = true;
              break;
            }
          }
        }

        // Verifica se o atributo não está presente e é obrigatório
        if (!blnPreenchido
            && "S".equals(objCategoriaAtributoTalento.getIndicativoObrigatoriedade())) {
          // Se for obrigatório, dispara um erro
          throw new CDException("O atributo " + strNomeCampo + " é obrigatório");
        } else if (!blnPresente) {
          // Se não for obrigatório, cria valoração vazia e insere na lista
          AtributoTalentoValorado objAtributoTalentoValorado = new AtributoTalentoValorado();
          objAtributoTalentoValorado.setCategoriaAtributoTalento(objCategoriaAtributoTalento);
          objAtributoTalentoValorado.setValoracao("");
          lstAtributosTalentoValorados.add(objAtributoTalentoValorado);
        }
      }

    } catch (Exception daoe) {
      CDException.dispararExcecao(daoe);
    } finally {
      DAO.desconectar();
    }
  }