Example usage for org.hibernate.criterion Restrictions gt

List of usage examples for org.hibernate.criterion Restrictions gt

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.criterion.*
  5. Restrictions
  6. gt

Introduction

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

Prototype

public static SimpleExpression gt(String propertyName, Object value)

Source Link

Document

Apply a "greater than" constraint to the named property

Usage

From source file:org.projectforge.timesheet.TimesheetDao.java

License:Open Source License

/**
 * Checks if the time sheet overlaps with another time sheet of the same user. Should be checked on every insert or update (also
 * undelete). For time collision detection deleted time sheets are ignored.
 * @return The existing time sheet with the time period collision.
 *///from w  w  w .  j av a  2  s  .c  o m
public boolean hasTimeOverlap(final TimesheetDO timesheet, final boolean throwException) {
    Validate.notNull(timesheet);
    Validate.notNull(timesheet.getUser());
    final QueryFilter queryFilter = new QueryFilter();
    queryFilter.add(Restrictions.eq("user", timesheet.getUser()));
    queryFilter.add(Restrictions.lt("startTime", timesheet.getStopTime()));
    queryFilter.add(Restrictions.gt("stopTime", timesheet.getStartTime()));
    if (timesheet.getId() != null) {
        // Update time sheet, do not compare with itself.
        queryFilter.add(Restrictions.ne("id", timesheet.getId()));
    }
    final List<TimesheetDO> list = getList(queryFilter);
    if (list != null && list.size() > 0) {
        final TimesheetDO ts = list.get(0);
        if (throwException == true) {
            log.info("Time sheet collision detected of time sheet " + timesheet + " with existing time sheet "
                    + ts);
            final String startTime = DateHelper.formatIsoTimestamp(ts.getStartTime());
            final String stopTime = DateHelper.formatIsoTimestamp(ts.getStopTime());
            throw new UserException("timesheet.error.timeperiodOverlapDetection", new MessageParam(ts.getId()),
                    new MessageParam(startTime), new MessageParam(stopTime));
        }
        return true;
    }
    return false;
}

From source file:org.rebioma.server.services.OccurrenceDbImpl.java

License:Apache License

/**
 * Adds a {@link Set} of search {@link OccurrenceFilter} to the
 * {@link Criteria}//from   w w  w  .  java  2 s.  c  om
 * 
 * @param criteria {@link Criteria} to be added with filters
 * @param user an id of a user in db.
 * @param searchFilters a filters that use for find Occurrences.
 * @param resultFilter the {@link ResultFilter} to determine what public
 *          filter is added.
 * @param tryCount TODO
 * @return {@link Set} of string filters was added to criteria.
 */
private Set<String> addCreterionByFilters(Criteria criteria, User user, Set<OccurrenceFilter> searchFilters,
        ResultFilter resultFilter, int tryCount) {
    Set<String> queryFilters = new HashSet<String>();
    // if (userId != null) {

    // }
    // Adds restrictions for each query filter:
    boolean isMyOccurrence = false;
    String ownerField = getOccurrencePropertyName("ownerEmail");
    List<Criterion> disjunctionCriterions = new ArrayList<Criterion>();
    for (OccurrenceFilter filter : searchFilters) {
        if ((filter.getOperator() != Operator.IS_EMPTY && filter.getOperator() != Operator.IS_NOT_EMPTY)
                && filter.value instanceof String && ((String) filter.value).equals("")) {
            continue;
        }
        if (filter.column.equalsIgnoreCase(ownerField)) {
            isMyOccurrence = true;
        }
        String queryFilter = null;
        Criterion criterion = null;
        // if filter column is "quickSearch" then this is a simple search
        if (filter.column.equalsIgnoreCase(filter.getPropertyName("quickSearch"))) {
            Criterion acceptedSpeciesCri = null;
            Criterion verbatimSpeciesCri = null;
            Criterion scientificNameCri = null;
            String acceptedSpecies = filter.getPropertyName("acceptedSpecies");
            String verbatimSpecies = filter.getPropertyName("verbatimSpecies");
            String scientificName = filter.getPropertyName("scientificName");
            if (tryCount == 1) {
                acceptedSpeciesCri = Restrictions.ilike(acceptedSpecies, filter.getValue().toString(),
                        MatchMode.START);
                verbatimSpeciesCri = Restrictions.ilike(verbatimSpecies, filter.getValue().toString(),
                        MatchMode.START);
                scientificNameCri = Restrictions.ilike(scientificName, filter.getValue().toString(),
                        MatchMode.START);
                queryFilter = acceptedSpecies + " like '" + filter.getValue() + "%' or " + verbatimSpecies
                        + " like '" + filter.getValue() + "%' or " + scientificName + " like '"
                        + filter.getValue() + "%'";
            } else if (tryCount == 2) {
                acceptedSpeciesCri = Restrictions.ilike(acceptedSpecies, filter.getValue().toString(),
                        MatchMode.ANYWHERE);
                verbatimSpeciesCri = Restrictions.ilike(verbatimSpecies, filter.getValue().toString(),
                        MatchMode.ANYWHERE);
                scientificNameCri = Restrictions.ilike(scientificName, filter.getValue().toString(),
                        MatchMode.ANYWHERE);
                queryFilter = acceptedSpecies + " like '%" + filter.getValue() + "%' or " + verbatimSpecies
                        + " like '%" + filter.getValue() + "%' or " + scientificName + " like '%"
                        + filter.getValue() + "%'";
            }
            criterion = Restrictions.or(scientificNameCri,
                    Restrictions.or(acceptedSpeciesCri, verbatimSpeciesCri));
        } else {
            Operator op = filter.getOperator();
            String value;
            switch (op) {
            case CONTAIN:
                value = (String) filter.getValue();
                criterion = Restrictions.ilike(filter.column, value, MatchMode.ANYWHERE);
                break;
            case EQUAL:
                criterion = null;
                if (filter.column.equals(filter.getPropertyName("sex"))) {
                    value = (String) filter.getValue();
                    if (value.equalsIgnoreCase("unknown")) {
                        Object[] filters = getComplexCriterion(
                                new String[] { "male", "female", "hermaphroditic" }, filter.column, "!=");
                        criterion = (Criterion) filters[0];
                        queryFilter = filters[1].toString();
                        // criterion = Restrictions.or(Restrictions., rhs)
                    } else {
                        criterion = Restrictions.eq(filter.column, value);
                    }
                } else if (filter.column.equals(filter.getPropertyName("BasisOfRecord"))) {
                    value = (String) filter.getValue();
                    if (value.equalsIgnoreCase("Non-standardSpecimen")) {
                        Object[] filters = getComplexCriterion(VALID_BASIS_OF_RECORDS, filter.column, "!=");
                        criterion = (Criterion) filters[0];
                        queryFilter = filters[1].toString();
                    } else {
                        criterion = Restrictions.eq(filter.column, value);
                    }
                } else {
                    // {wd} on utilise "upper()" si type column = String 
                    if (StringUtil.isType(Occurrence.class, filter.column, String.class))
                        criterion = Restrictions.sqlRestriction("upper({alias}."
                                + StringUtil.columnName(Occurrence.class, filter.column) + ") = upper(?)",
                                filter.getValue(), Hibernate.STRING);
                    else
                        criterion = Restrictions.eq(filter.column, filter.getValue());
                }
                break;
            case NOT_CONTAIN:
                value = (String) filter.getValue();
                criterion = Restrictions.not(Restrictions.ilike(filter.column, value, MatchMode.ANYWHERE));
                break;
            case NOT_EQUAL:
                criterion = null;
                if (filter.column.equals(filter.getPropertyName("sex"))) {
                    value = (String) filter.getValue();
                    if (value.equalsIgnoreCase("unknown")) {
                        Object[] filters = getComplexCriterion(
                                new String[] { "male", "female", "hermaphroditic" }, filter.column, "=");
                        criterion = (Criterion) filters[0];
                        queryFilter = filters[1].toString();
                        // criterion = Restrictions.or(Restrictions., rhs)
                    } else {
                        criterion = Restrictions.ne(filter.column, value);
                    }
                } else if (filter.column.equals(filter.getPropertyName("BasisOfRecord"))) {
                    value = (String) filter.getValue();
                    if (value.equalsIgnoreCase("Non-standardSpecimen")) {
                        Object[] filters = getComplexCriterion(VALID_BASIS_OF_RECORDS, filter.column, "=");
                        criterion = (Criterion) filters[0];
                        queryFilter = filters[1].toString();
                    } else {
                        criterion = Restrictions.ne(filter.column, value);
                    }
                } else {
                    criterion = Restrictions.ne(filter.column, filter.getValue());
                }
                break;
            case START_WITH:
                value = (String) filter.getValue();
                criterion = Restrictions.ilike(filter.column, value, MatchMode.START);
                break;
            case NOT_START_WITH:
                value = (String) filter.getValue();
                criterion = Restrictions.not(Restrictions.ilike(filter.column, value, MatchMode.START));
                break;
            case LESS:
                criterion = Restrictions.lt(filter.column, filter.getValue());
                break;
            case GREATER:
                criterion = Restrictions.gt(filter.column, filter.getValue());
                break;
            case LESS_EQUAL:
                criterion = Restrictions.le(filter.column, filter.getValue());
                break;
            case GREATER_EQUAL:
                criterion = Restrictions.ge(filter.column, filter.getValue());
                break;
            case IN:
                if (filter.getValue() instanceof Collection<?>) {
                    criterion = Restrictions.in(filter.column, (Collection<?>) filter.getValue());
                    //{WD
                } else if (StringUtil.isType(Occurrence.class, filter.column, Integer.class)) {
                    Object values[] = filter.getIntegerValues();
                    criterion = Restrictions.in(filter.column, values);
                    //}
                } else {
                    String values[] = filter.getCollectionValues();
                    criterion = Restrictions.in(filter.column, values);
                }
                break;
            case NOT_IN:
                //{WD
                if (StringUtil.isType(Occurrence.class, filter.column, Integer.class)) {
                    Object arryValues[] = filter.getIntegerValues();
                    criterion = Restrictions.not(Restrictions.in(filter.column, arryValues));
                    //}
                } else {
                    String arryValues[] = filter.getCollectionValues();
                    criterion = Restrictions.not(Restrictions.in(filter.column, arryValues));
                }
                break;
            case IS_EMPTY:
                if (StringUtil.isString(Occurrence.class, filter.column)) {
                    // System.out.println(filter.column + "null and empty");
                    criterion = Restrictions.or(Restrictions.isNull(filter.column),
                            Restrictions.eq(filter.column, ""));
                } else {
                    // System.out.println(filter.column + "null");
                    criterion = Restrictions.isNull(filter.column);
                }
                // System.out.println(criterion);
                break;
            case IS_NOT_EMPTY:
                criterion = Restrictions.and(Restrictions.isNotNull(filter.column),
                        Restrictions.ne(filter.column, ""));
                System.out.println(criterion);
                break;
            }
        }

        if (criterion != null) {
            if (queryFilter == null) {
                queryFilter = filter.toString();
            }
            queryFilters.add(queryFilter);
            if (filter.isDisjunction()) {
                disjunctionCriterions.add(criterion);
            } else {
                criteria.add(criterion);
            }

        }
    }
    Set<String> filtersString = new HashSet<String>();
    Criterion publicCriterion = getPublicCriterion(user, resultFilter, isMyOccurrence, filtersString);
    if (publicCriterion != null) {
        criteria.add(publicCriterion);
        queryFilters.addAll(filtersString);
    }
    Criterion disjunctionCriterion = null;
    for (Criterion c : disjunctionCriterions) {
        if (disjunctionCriterion == null) {
            disjunctionCriterion = Restrictions.disjunction().add(c);
        } else {
            disjunctionCriterion = Restrictions.or(disjunctionCriterion, c);
        }
    }
    if (disjunctionCriterion != null) {
        criteria.add(disjunctionCriterion);
    }
    return queryFilters;
}

From source file:org.sakaiproject.genericdao.hibernate.HibernateBasicGenericDao.java

License:Apache License

/**
 * Build the Criteria object here to reduce code duplication
 * @param entityClass//from  w  w  w.j a v a2  s. c om
 * @param search a Search object (possibly only partially complete)
 * @return a DetachedCriteria object
 */
private DetachedCriteria buildCriteria(Class<?> entityClass, Search search) {
    // Checks to see if the required params are set and throws exception if not
    if (search == null) {
        throw new IllegalArgumentException("search cannot be null");
    }

    // Build the criteria object
    DetachedCriteria criteria = DetachedCriteria.forClass(entityClass);

    // Only add in restrictions if there are some to add
    if (search.getRestrictions() != null && search.getRestrictions().length > 0) {
        Junction junction = Expression.conjunction(); // AND
        if (!search.conjunction) {
            // set to use disjunction
            junction = Expression.disjunction(); // OR
        }
        criteria.add(junction);

        // put in the restrictions
        for (int i = 0; i < search.getRestrictions().length; i++) {
            String property = search.getRestrictions()[i].property;
            Object value = search.getRestrictions()[i].value;
            if (property == null || value == null) {
                throw new IllegalArgumentException("restrictions property and value cannot be null or empty");
            }
            if (value.getClass().isArray()) {
                // special handling for "in" type comparisons
                Object[] objectArray = (Object[]) value;
                if (objectArray.length == 1) {
                    value = objectArray[0];
                } else if (objectArray.length > 1) {
                    if (Restriction.NOT_EQUALS == search.getRestrictions()[i].comparison) {
                        junction.add(Restrictions.not(Restrictions.in(property, objectArray)));
                    } else {
                        junction.add(Restrictions.in(property, objectArray));
                    }
                } else {
                    // do nothing for now, this is slightly invalid but not worth dying over
                }
            }

            if (!value.getClass().isArray()) {
                switch (search.getRestrictions()[i].comparison) {
                case Restriction.EQUALS:
                    junction.add(Restrictions.eq(property, value));
                    break;
                case Restriction.GREATER:
                    junction.add(Restrictions.gt(property, value));
                    break;
                case Restriction.LESS:
                    junction.add(Restrictions.lt(property, value));
                    break;
                case Restriction.LIKE:
                    junction.add(Restrictions.like(property, value));
                    break;
                case Restriction.NULL:
                    junction.add(Restrictions.isNull(property));
                    break;
                case Restriction.NOT_NULL:
                    junction.add(Restrictions.isNotNull(property));
                    break;
                case Restriction.NOT_EQUALS:
                    junction.add(Restrictions.ne(property, value));
                    break;
                }
            }
        }
    }

    // handle the sorting (sort param can be null for no sort)
    if (search.getOrders() != null) {
        for (int i = 0; i < search.getOrders().length; i++) {
            if (search.getOrders()[i].ascending) {
                criteria.addOrder(org.hibernate.criterion.Order.asc(search.getOrders()[i].property));
            } else {
                criteria.addOrder(org.hibernate.criterion.Order.desc(search.getOrders()[i].property));
            }
        }
    }

    return criteria;
}

From source file:org.sakaiproject.lessonbuildertool.model.SimplePageToolDaoImpl.java

License:Educational Community License

public List<Item> getTiposCaracteristicas() {

    //id item > 3, para los tipos de caracteristicas y no sea 8 porque 8 es contexto

    DetachedCriteria d = DetachedCriteria.forClass(Item.class).add(Restrictions.gt("idItem", 3))
            .add(Restrictions.ne("idItem", 8));

    List<Item> list = getHibernateTemplate().findByCriteria(d);

    //      List<String> list = SqlService.dbRead("select nombre from tipo where tipoTipo = 2");
    //      List<String> list1 = SqlService.dbRead("select idTipo from tipo where tipoTipo = 2");

    //      if (list.size() > 0) {
    //         int i = 0;
    ////         for(Caracteristica c : list)
    ////         {
    ////            listNombres[i]=c.getNombre();
    ////            i++;
    ////         }
    //         for(i =0; i< list.size();i++)
    //         {/*from ww w .ja  v  a 2 s  .  c o m*/
    //            listTipos.add(new TipoImpl(Integer.valueOf(list1.get(i)),
    //                  Integer.valueOf(list1.get(i)),
    //                  list.get(i)));
    //         }
    //      }

    //return listTipos;
    return list;
}

From source file:org.sakaiproject.signup.dao.SignupMeetingDaoImpl.java

License:Educational Community License

/**
 * {@inheritDoc}//ww w .j av  a  2s .com
 */
@SuppressWarnings("unchecked")
public List<SignupMeeting> getRecurringSignupMeetings(String siteId, Long recurrenceId, Date currentTime) {
    DetachedCriteria criteria = DetachedCriteria.forClass(SignupMeeting.class)
            .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)
            .add(Restrictions.eq("recurrenceId", recurrenceId)).add(Restrictions.gt("endTime", currentTime))
            .addOrder(Order.asc("startTime")).createCriteria("signupSites")
            .add(Restrictions.eq("siteId", siteId));

    return (List<SignupMeeting>) getHibernateTemplate().findByCriteria(criteria);
}

From source file:org.sculptor.framework.accessimpl.jpahibernate.JpaHibFindByConditionAccessImpl.java

License:Apache License

private Criterion makeCriterion(ConditionalCriteria crit) {
    if (crit == null) {
        return null;
    }//ww  w  . j a va 2 s  . c  o  m

    ConditionalCriteria.Operator operator = crit.getOperator();
    if (Operator.Equal.equals(operator)) {
        return Restrictions.eq(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.IgnoreCaseEqual.equals(operator)) {
        return Restrictions.eq(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant())
                .ignoreCase();
    } else if (Operator.LessThan.equals(operator)) {
        return Restrictions.lt(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.LessThanOrEqual.equals(operator)) {
        return Restrictions.le(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.GreatThan.equals(operator)) {
        return Restrictions.gt(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.GreatThanOrEqual.equals(operator)) {
        return Restrictions.ge(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.Like.equals(operator)) {
        // Hibernate bug HHH-5339 + PostgreSQL missing 'number like string' conversion
        return new NumericLikeExpression(makePathWithAlias(crit.getPropertyFullName()),
                crit.getFirstOperant().toString(), false);
    } else if (Operator.IgnoreCaseLike.equals(operator)) {
        // Hibernate bug HHH-5339 + PostgreSQL missing 'number like string' conversion
        return new NumericLikeExpression(makePathWithAlias(crit.getPropertyFullName()),
                crit.getFirstOperant().toString(), true);
    } else if (Operator.IsNull.equals(operator)) {
        return Restrictions.isNull(makePathWithAlias(crit.getPropertyFullName()));
    } else if (Operator.IsNotNull.equals(operator)) {
        return Restrictions.isNotNull(makePathWithAlias(crit.getPropertyFullName()));
    } else if (Operator.IsEmpty.equals(operator)) {
        return Restrictions.isEmpty(makePathWithAlias(crit.getPropertyFullName()));
    } else if (Operator.IsNotEmpty.equals(operator)) {
        return Restrictions.isNotEmpty(makePathWithAlias(crit.getPropertyFullName()));
    } else if (Operator.Not.equals(operator)) {
        return Restrictions.not(makeCriterion((ConditionalCriteria) crit.getFirstOperant()));
    } else if (Operator.Or.equals(operator) && crit.getFirstOperant() instanceof List<?>) {
        Disjunction disj = Restrictions.disjunction();
        List<?> disjList = (List<?>) crit.getFirstOperant();
        for (Object disjPart : disjList) {
            disj.add(makeCriterion((ConditionalCriteria) disjPart));
        }
        return disj;
    } else if (Operator.Or.equals(operator)) {
        return Restrictions.or(makeCriterion((ConditionalCriteria) crit.getFirstOperant()),
                makeCriterion((ConditionalCriteria) crit.getSecondOperant()));
    } else if (Operator.And.equals(operator) && crit.getFirstOperant() instanceof List<?>) {
        Conjunction conj = Restrictions.conjunction();
        List<?> conjList = (List<?>) crit.getFirstOperant();
        for (Object conjPart : conjList) {
            conj.add(makeCriterion((ConditionalCriteria) conjPart));
        }
        return conj;
    } else if (Operator.And.equals(operator)) {
        return Restrictions.and(makeCriterion((ConditionalCriteria) crit.getFirstOperant()),
                makeCriterion((ConditionalCriteria) crit.getSecondOperant()));
    } else if (Operator.In.equals(operator)) {
        if (crit.getFirstOperant() instanceof Collection<?>) {
            return Restrictions.in(makePathWithAlias(crit.getPropertyFullName()),
                    (Collection<?>) crit.getFirstOperant());
        } else {
            return Restrictions.in(makePathWithAlias(crit.getPropertyFullName()),
                    (Object[]) crit.getFirstOperant());
        }
    } else if (Operator.Between.equals(operator)) {
        return Restrictions.between(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant(),
                crit.getSecondOperant());
    } else if (Operator.DistinctRoot.equals(operator)) {
        realDistinctRoot = true;
        return null;
    } else if (Operator.ProjectionRoot.equals(operator)) {
        resultTransformer = Criteria.PROJECTION;
        return null;
    } else if (Operator.EqualProperty.equals(operator)) {
        return Restrictions.eqProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else if (Operator.LessThanProperty.equals(operator)) {
        return Restrictions.ltProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else if (Operator.LessThanOrEqualProperty.equals(operator)) {
        return Restrictions.leProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else if (Operator.GreatThanProperty.equals(operator)) {
        return Restrictions.gtProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else if (Operator.GreatThanOrEqualProperty.equals(operator)) {
        return Restrictions.geProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else {
        return null;
    }
}

From source file:org.shredzone.cilla.core.repository.impl.PageDaoHibImpl.java

License:Open Source License

@Transactional(readOnly = true)
@Override/*  w  ww  .  jav a  2 s  .c o  m*/
public Date[] fetchMinMaxModification() {
    Date now = new Date();

    Criteria crit = getCurrentSession().createCriteria(Page.class);

    crit.add(Restrictions.and(Restrictions.isNotNull("publication"), Restrictions.le("publication", now)));

    crit.add(Restrictions.or(Restrictions.isNull("expiration"), Restrictions.gt("expiration", now)));

    crit.add(Restrictions.eq("hidden", false));

    ProjectionList proj = Projections.projectionList();
    proj.add(Projections.min(pageOrder.getColumn()));
    proj.add(Projections.max(pageOrder.getColumn()));
    crit.setProjection(proj);
    Object[] row = (Object[]) crit.uniqueResult();

    Date[] result = new Date[2];
    result[0] = (Date) row[0];
    result[1] = (Date) row[1];
    return result;
}

From source file:org.shredzone.cilla.service.impl.TagServiceImpl.java

License:Open Source License

@SuppressWarnings("unchecked")
@Transactional(readOnly = true)/*from  w w w .ja  va2s  .co m*/
@Cacheable("tagCloud")
@Override
public Map<Tag, Float> createTagCloud(long limit) {
    Date now = new Date();
    Date limitDate = new Date(now.getTime() - limit);

    List<Page> pages = pageDao.criteria()
            .add(Restrictions.and(Restrictions.isNotNull("publication"),
                    Restrictions.between("publication", limitDate, now)))
            .add(Restrictions.or(Restrictions.isNull("expiration"), Restrictions.gt("expiration", now)))
            .add(Restrictions.isNotEmpty("tags")).list();

    return computeTagCloud(pages, limitDate.getTime(), limit);
}

From source file:org.shredzone.cilla.service.search.strategy.AbstractSearchStrategy.java

License:Open Source License

/**
 * Creates a {@link Criteria} object for the filter given in the
 * {@link SearchResultImpl}./*from w  ww . j a  v  a  2s  .com*/
 */
protected Criteria createCriteria(SearchResultImpl result) throws CillaServiceException {
    Criteria crit = pageDao.criteria();
    crit.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);

    crit.add(Restrictions.and(Restrictions.isNotNull("publication"),
            Restrictions.le("publication", result.getNow())));

    crit.add(
            Restrictions.or(Restrictions.isNull("expiration"), Restrictions.gt("expiration", result.getNow())));

    crit.add(Restrictions.eq("hidden", false));

    FilterModel filter = result.getFilter();
    if (filter != null) {
        if (filter.getCategory() != null) {
            // I'd prefer to use Restrictions.in instead, but this seems to be difficult.
            // http://stackoverflow.com/questions/407737/hibernate-criteria-querying-tables-in-nm-relationship
            Disjunction dis = Restrictions.disjunction();
            result.getEffectiveCategories().stream().mapToLong(Category::getId)
                    .forEach(id -> dis.add(Restrictions.idEq(id)));
            crit.createCriteria("categories").add(dis);
        }

        if (filter.getTag() != null) {
            long tagId = filter.getTag().getId();
            Disjunction dis = Restrictions.disjunction();

            // All pages with the requested tag
            crit.createAlias("tags", "tt");
            dis.add(Restrictions.eq("tt.id", tagId));

            // All pages with pictures in a gallery section having the requested tag
            DetachedCriteria subcrit = DetachedCriteria.forClass(GallerySection.class);
            subcrit.createCriteria("pictures").createCriteria("tags").add(Restrictions.idEq(tagId));
            subcrit.setProjection(Projections.distinct(Projections.property("page.id")));
            dis.add(Subqueries.propertyIn("id", subcrit));

            crit.add(dis);
        }

        if (filter.getCreator() != null) {
            crit.add(Restrictions.eq("creator", filter.getCreator()));
        }

        if (filter.getPage() != null) {
            crit.add(Restrictions.idEq(filter.getPage().getId()));
        }

        if (filter.getDate() != null) {
            DateRange dr = filter.getDate();
            PageOrder order = (filter.getOrder() != null ? filter.getOrder() : PageOrder.PUBLICATION);
            crit.add(Restrictions.between(order.getColumn(), dr.getFromDate().getTime(),
                    dr.getThruDate().getTime()));
        }

        if (filter.getQuery() != null) {
            // No challenge protected pages for context search, because protected
            // contents may be revealed in the search results.
            crit.add(Restrictions.isNull("challenge"));
        }
    }

    return crit;
}

From source file:org.smallmind.persistence.orm.hibernate.HibernateDao.java

License:Open Source License

public List<D> list(final I greaterThan, final int maxResults, final int fetchSize) {

    return listByCriteria(new CriteriaDetails() {

        @Override//  w  ww.j  ava  2s .  c  o  m
        public Criteria completeCriteria(Criteria criteria) {

            return criteria.add(Restrictions.gt("id", greaterThan)).addOrder(Order.asc("id"))
                    .setMaxResults(maxResults).setFetchSize(fetchSize);
        }
    });
}