Example usage for org.hibernate.criterion Restrictions not

Introduction

In this page you can find the example usage for org.hibernate.criterion Restrictions not.

Prototype

public static Criterion not(Criterion expression)

Source Link

Document

Return the negation of an expression

Usage

From source file:au.org.theark.phenotypic.model.dao.PhenotypicDao.java

License:Open Source License

/**
 * Shows all the available pheno fields which not linked with categories.
 *///from w ww .j  av a 2  s.  c  o m
@Override
public List<PhenoDataSetField> getAvailablePhenoFieldListNotInLinked(Study study,
        ArkFunction arkFunctionPhenoField, ArkFunction arkFunctionPhenoCollection, ArkUser arkUser)
        throws ArkSystemException {
    List<LinkPhenoDataSetCategoryField> linkPhenoDataSetCategoryFields = getLinkPhenoDataSetCategoryFieldLst(
            study, arkFunctionPhenoCollection, arkUser);
    List<Long> linkedPhenoDataIdLst = new ArrayList<Long>();
    for (LinkPhenoDataSetCategoryField linkPhenoDataSetCategoryField : linkPhenoDataSetCategoryFields) {
        linkedPhenoDataIdLst.add(linkPhenoDataSetCategoryField.getPhenoDataSetField().getId());
    }
    Criteria criteria = getSession().createCriteria(PhenoDataSetField.class);
    criteria.add(Restrictions.eq("arkFunction", arkFunctionPhenoField));
    criteria.add(Restrictions.eq("study", study));
    if (!linkedPhenoDataIdLst.isEmpty()) {
        criteria.add(Restrictions.not(Restrictions.in("id", linkedPhenoDataIdLst)));
    }
    return criteria.list();
}

From source file:bernardo.venda.controle.ProdutoControle.java

public List<Produto> findAllAvalaible() {
    List<Produto> l = getSession().createCriteria(Produto.class)
            .add(Restrictions.not(Restrictions.eq("quantidadeActual", 0))).addOrder(Order.asc("descricao"))
            .list();//from  w w  w. j a va2s .c  o  m
    return l;
}

From source file:br.com.hrstatus.dao.impl.ServersDAO.java

License:Open Source License

public int countServerWithLog() {

    log.fine("[ " + userInfo.getLoggedUsername() + " ] countServerWithLog()");

    try {/*from  w  w  w. j a va  2  s  . c o m*/
        final Criteria criteria = session().createCriteria(Servidores.class);
        criteria.add(Restrictions.not(Restrictions.eq("logDir", "")));
        criteria.setProjection(Projections.rowCount());
        final int count = ((Long) criteria.uniqueResult()).intValue();
        log.fine("[ " + userInfo.getLoggedUsername() + " ] countServerWithLog -> found: " + count);
        return count;
    } catch (Exception e) {
        log.severe("[ " + userInfo.getLoggedUsername() + " ] Error: " + e);
        return 0;
    }
}

From source file:br.com.hslife.orcamento.repository.FaturaCartaoRepository.java

License:Open Source License

public FaturaCartao lastFaturaCartaoFechada(Conta conta) {
    StatusFaturaCartao status[] = { StatusFaturaCartao.ABERTA, StatusFaturaCartao.FUTURA };
    Criteria criteria = getSession().createCriteria(FaturaCartao.class);
    criteria.add(Restrictions.eq("conta.id", conta.getId()));
    criteria.add(Restrictions.not(Restrictions.in("statusFaturaCartao", status)));
    return (FaturaCartao) criteria.addOrder(Order.desc("dataVencimento"))
            .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).setMaxResults(1).uniqueResult();
}

From source file:br.com.OCTur.control.DAO.PessoaDAO.java

public Pessoa pegarPorUsuarioEditar(String text) {
    entity = (Pessoa) criteria.add(Restrictions.eq("usuario", text))
            .add(Restrictions.not(Restrictions.eq("id", Sessao.pessoa.getId()))).uniqueResult();
    closeSession();//from   ww  w.  j ava 2  s .c  o  m
    return entity;
}

From source file:br.com.SistemaOCTur.dao.UsuarioDAO.java

public List<Usuario> pegarTodosPorNaoCargo(Cargo cargo) {
    entitys = criteria.add(Restrictions.not(Restrictions.eq("cargo", cargo))).list();
    session.close();/*from ww w . j  av a 2s  .  c o m*/
    return entitys;
}

From source file:br.com.SistemaOCTur.dao.UsuarioDAO.java

public List<Usuario> pegarTodosPorNaoCargo(String nome, Cargo cargo) {
    entitys = criteria.add(Restrictions.like("nome", nome, MatchMode.START))
            .add(Restrictions.not(Restrictions.eq("cargo", cargo))).list();
    session.close();//www  . j av  a 2  s  . c om
    return entitys;
}

From source file:br.gov.jfrj.siga.dp.dao.CpDao.java

License:Open Source License

public List<DpPessoa> pessoasPorLotacao(Long id, Boolean incluirSublotacoes, Boolean somenteServidor,
        SituacaoFuncionalEnum situacoesFuncionais) throws AplicacaoException {
    if (id == null || id == 0)
        return null;

    DpLotacao lotacao = consultar(id, DpLotacao.class, false);

    List<DpLotacao> sublotacoes = new ArrayList<DpLotacao>();
    sublotacoes.add(lotacao);/*from  w w w.j a v  a2s  . c o m*/
    if (incluirSublotacoes) {
        List<DpLotacao> lotacoes = listarLotacoes();
        boolean continuar = true;
        while (continuar) {
            continuar = false;
            for (DpLotacao lot : lotacoes) {
                if (sublotacoes.contains(lot))
                    continue;
                if (sublotacoes.contains(lot.getLotacaoPai())) {
                    if (!lot.isSubsecretaria()) {
                        sublotacoes.add(lot);
                        continuar = true;
                    }
                }
            }
        }
    }

    List<DpPessoa> lstCompleta = new ArrayList<DpPessoa>();
    for (DpLotacao lot : sublotacoes) {

        Criteria c = HibernateUtil.getSessao().createCriteria(DpPessoa.class);
        c.createAlias("cargo", "c");

        c.add(Restrictions.eq("lotacao.id", lot.getId()));
        if (somenteServidor) {
            c.add(Restrictions.not(Restrictions.in("c.nomeCargo",
                    new String[] { "ESTAGIARIO", "JUIZ SUBSTITUTO", "JUIZ FEDERAL" })));
        }

        c.add(Restrictions.in("situacaoFuncionalPessoa", situacoesFuncionais.getValor()));

        c.add(Restrictions.isNull("dataFimPessoa"));

        c.addOrder(Order.asc("nomePessoa"));

        lstCompleta.addAll((List<DpPessoa>) c.list());

    }
    return lstCompleta;
}

From source file:com.abiquo.server.core.infrastructure.RepositoryDAO.java

License:Open Source License

public boolean existRepositoryInOtherDatacenter(Datacenter datacenter, String repositoryLocation) {
    Criterion notDatacenter = Restrictions.not(thisDatacenter(datacenter));
    Criteria criteria = createCriteria(notDatacenter, thisLocation(repositoryLocation));

    criteria.setProjection(Projections.projectionList().add(Projections.rowCount()));

    Long count = (Long) criteria.uniqueResult();
    return count != null && count.intValue() > 0;
}

From source file:com.algoTrader.CriteriaSearch.java

/**
 * Adds an <code>Restrictions</code> to a <code>Criteria</code>.
 *
 * @param criteria//  ww  w  .  ja  v a2 s  .com
 * @param parameterName
 * @param parameterValue
 * @param comparator
 * @param matchMode
 */
private void addExpression(Criteria criteria, String parameterName, Object parameterValue, int comparator,
        MatchMode matchMode) {
    switch (comparator) {
    case SearchParameter.NOT_NULL_COMPARATOR: {
        criteria.add(Restrictions.isNotNull(parameterName));
        break;
    }
    case SearchParameter.NULL_COMPARATOR: {
        criteria.add(Restrictions.isNull(parameterName));
        break;
    }
    case SearchParameter.EMPTY_COMPARATOR: {
        criteria.add(Restrictions.isEmpty(parameterName));
        break;
    }
    case SearchParameter.NOT_EMPTY_COMPARATOR: {
        criteria.add(Restrictions.isNotEmpty(parameterName));
        break;
    }
    default: {
        if (parameterValue != null) {
            switch (comparator) {
            case SearchParameter.LIKE_COMPARATOR: {
                if ((matchMode != null) && (parameterValue instanceof String)) {
                    criteria.add(Restrictions.like(parameterName, (String) parameterValue, matchMode));
                } else {
                    criteria.add(Restrictions.like(parameterName, parameterValue));
                }
                break;
            }
            case SearchParameter.NOT_LIKE_COMPARATOR: {
                SimpleExpression expression;
                if ((matchMode != null) && (parameterValue instanceof String)) {
                    expression = Restrictions.like(parameterName, (String) parameterValue, matchMode);
                } else {
                    expression = Restrictions.like(parameterName, parameterValue);
                }
                criteria.add(Restrictions.not(expression));
                break;
            }
            case SearchParameter.INSENSITIVE_LIKE_COMPARATOR: {
                if ((matchMode != null) && (parameterValue instanceof String)) {
                    criteria.add(Restrictions.ilike(parameterName, (String) parameterValue, matchMode));
                } else {
                    criteria.add(Restrictions.ilike(parameterName, parameterValue));
                }
                break;
            }
            case SearchParameter.NOT_INSENSITIVE_LIKE_COMPARATOR: {
                Criterion criterion;
                if ((matchMode != null) && (parameterValue instanceof String)) {
                    criterion = Restrictions.ilike(parameterName, (String) parameterValue, matchMode);
                } else {
                    criterion = Restrictions.ilike(parameterName, parameterValue);
                }
                criteria.add(Restrictions.not(criterion));
                break;
            }
            case SearchParameter.EQUAL_COMPARATOR: {
                criteria.add(Restrictions.eq(parameterName, parameterValue));
                break;
            }
            case SearchParameter.GREATER_THAN_OR_EQUAL_COMPARATOR: {
                criteria.add(Restrictions.ge(parameterName, parameterValue));
                break;
            }
            case SearchParameter.GREATER_THAN_COMPARATOR: {
                criteria.add(Restrictions.gt(parameterName, parameterValue));
                break;
            }
            case SearchParameter.LESS_THAN_OR_EQUAL_COMPARATOR: {
                criteria.add(Restrictions.le(parameterName, parameterValue));
                break;
            }
            case SearchParameter.LESS_THAN_COMPARATOR: {
                criteria.add(Restrictions.lt(parameterName, parameterValue));
                break;
            }
            case SearchParameter.IN_COMPARATOR: {
                if (parameterValue instanceof Collection) {
                    criteria.add(Restrictions.in(parameterName, (Collection) parameterValue));
                }
                break;
            }
            case SearchParameter.NOT_IN_COMPARATOR: {
                if (parameterValue instanceof Collection) {
                    criteria.add(Restrictions.not(Restrictions.in(parameterName, (Collection) parameterValue)));
                }
                break;
            }
            case SearchParameter.NOT_EQUAL_COMPARATOR: {
                criteria.add(Restrictions.ne(parameterName, parameterValue));
                break;
            }
            }
        } else {
            criteria.add(Restrictions.isNull(parameterName));
        }
    }
    }
}