Beispiel #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();
    }
  }
Beispiel #2
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;
  }
Beispiel #3
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;
  }
Beispiel #4
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();
    }
  }
Beispiel #5
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();
    }
  }