Example usage for org.hibernate.criterion Restrictions lt

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

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

Introduction

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

Prototype

public static SimpleExpression lt(String propertyName, Object value)

Source Link

Document

Apply a "less than" constraint to the named property

Usage

From source file:org.projectforge.business.teamcal.event.TeamEventDao.java

License:Open Source License

/**
 * The time period of the filter will be extended by one day. This is needed due to all day events which are stored in
 * UTC. The additional events in the result list not matching the time period have to be removed by caller!
 *
 * @param filter//www.  ja v a2s.  co m
 * @return
 */
private QueryFilter buildQueryFilter(final TeamEventFilter filter) {
    final QueryFilter queryFilter = new QueryFilter(filter);
    final Collection<Integer> cals = filter.getTeamCals();
    if (CollectionUtils.isNotEmpty(cals) == true) {
        queryFilter.add(Restrictions.in("calendar.id", cals));
    } else if (filter.getTeamCalId() != null) {
        queryFilter.add(Restrictions.eq("calendar.id", filter.getTeamCalId()));
    }
    // Following period extension is needed due to all day events which are stored in UTC. The additional events in the result list not
    // matching the time period have to be removed by caller!
    Date startDate = filter.getStartDate();
    if (startDate != null) {
        startDate = new Date(startDate.getTime() - ONE_DAY);
    }
    Date endDate = filter.getEndDate();
    if (endDate != null) {
        endDate = new Date(endDate.getTime() + ONE_DAY);
    }
    // limit events to load to chosen date view.
    if (startDate != null && endDate != null) {
        if (filter.isOnlyRecurrence() == false) {
            queryFilter.add(Restrictions.or(
                    (Restrictions.or(Restrictions.between("startDate", startDate, endDate),
                            Restrictions.between("endDate", startDate, endDate))),
                    // get events whose duration overlap with chosen duration.
                    (Restrictions.and(Restrictions.le("startDate", startDate),
                            Restrictions.ge("endDate", endDate)))));
        } else {
            queryFilter.add(
                    // "startDate" < endDate && ("recurrenceUntil" == null ||"recurrenceUntil" > startDate)
                    (Restrictions.and(Restrictions.lt("startDate", endDate),
                            Restrictions.or(Restrictions.isNull("recurrenceUntil"),
                                    Restrictions.gt("recurrenceUntil", startDate)))));
        }
    } else if (startDate != null) {
        if (filter.isOnlyRecurrence() == false) {
            queryFilter.add(Restrictions.ge("startDate", startDate));
        } else {
            // This branch is reached for subscriptions and calendar downloads.
            queryFilter.add(
                    // "recurrenceUntil" == null ||"recurrenceUntil" > startDate
                    Restrictions.or(Restrictions.isNull("recurrenceUntil"),
                            Restrictions.gt("recurrenceUntil", startDate)));
        }
    } else if (endDate != null) {
        queryFilter.add(Restrictions.le("startDate", endDate));
    }
    queryFilter.addOrder(Order.desc("startDate"));
    if (log.isDebugEnabled() == true) {
        log.debug(ToStringBuilder.reflectionToString(filter));
    }
    return queryFilter;
}

From source file:org.projectforge.business.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.
 * /*from   www .j  ava2 s .c o  m*/
 * @return The existing time sheet with the time period collision.
 */
public boolean hasTimeOverlap(final TimesheetDO timesheet, final boolean throwException) {
    long begin = System.currentTimeMillis();
    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));
        }
        long end = System.currentTimeMillis();
        log.info("TimesheetDao.hasTimeOverlap took: " + (end - begin) + " ms.");
        return true;
    }
    long end = System.currentTimeMillis();
    log.info("TimesheetDao.hasTimeOverlap took: " + (end - begin) + " ms.");
    return false;
}

From source file:org.projectforge.fibu.kost.BuchungssatzDao.java

License:Open Source License

@Override
public List<BuchungssatzDO> getList(BaseSearchFilter filter) {
    accessChecker.checkIsLoggedInUserMemberOfGroup(ProjectForgeGroup.FINANCE_GROUP,
            ProjectForgeGroup.CONTROLLING_GROUP);
    final BuchungssatzFilter myFilter;
    if (filter instanceof BuchungssatzFilter) {
        myFilter = (BuchungssatzFilter) filter;
    } else {/* w  w  w. j  a  v a 2s  .  co m*/
        myFilter = new BuchungssatzFilter(filter);
    }
    final QueryFilter queryFilter = new QueryFilter(filter);
    if (validateTimeperiod(myFilter) == false) {
        throw new UserException("fibu.buchungssatz.error.invalidTimeperiod");
    }
    if (myFilter.getFromMonth() < 0) {
        // Kein Von-Monat gesetzt.
        queryFilter.add(Restrictions.eq("year", myFilter.getFromYear()));
        queryFilter.add(Restrictions.between("month", 0, 11));
    } else if (myFilter.getToYear() > 0) {
        if (myFilter.getFromYear() == myFilter.getToYear()) {
            queryFilter.add(Restrictions.eq("year", myFilter.getFromYear()));
            queryFilter.add(Restrictions.between("month", myFilter.getFromMonth(), myFilter.getToMonth()));
        } else {
            // between but different years
            queryFilter.add(Restrictions.disjunction()
                    .add(Restrictions.and(Restrictions.eq("year", myFilter.getFromYear()),
                            Restrictions.ge("month", myFilter.getFromMonth())))
                    .add(Restrictions.and(Restrictions.eq("year", myFilter.getToYear()),
                            Restrictions.le("month", myFilter.getToMonth())))
                    .add(Restrictions.and(Restrictions.gt("year", myFilter.getFromYear()),
                            Restrictions.lt("year", myFilter.getToYear()))));
        }
    } else {
        // Nur Von-Monat gesetzt.
        queryFilter.add(Restrictions.eq("year", myFilter.getFromYear()));
        queryFilter.add(Restrictions.eq("month", myFilter.getFromMonth()));
    }
    queryFilter.addOrder(Order.asc("year")).addOrder(Order.asc("month")).addOrder(Order.asc("satznr"));
    final List<BuchungssatzDO> list = getList(queryFilter);
    return list;
}

From source file:org.projectforge.plugins.teamcal.event.TeamEventDao.java

License:Open Source License

/**
 * The time period of the filter will be extended by one day. This is needed due to all day events which are stored in UTC. The additional
 * events in the result list not matching the time period have to be removed by caller!
 * @param filter/*  w  w  w .  ja va 2s. c o  m*/
 * @param allDay
 * @return
 */
private QueryFilter buildQueryFilter(final TeamEventFilter filter) {
    final QueryFilter queryFilter = new QueryFilter(filter);
    final Collection<Integer> cals = filter.getTeamCals();
    if (CollectionUtils.isNotEmpty(cals) == true) {
        queryFilter.add(Restrictions.in("calendar.id", cals));
    } else if (filter.getTeamCalId() != null) {
        queryFilter.add(Restrictions.eq("calendar.id", filter.getTeamCalId()));
    }
    // Following period extension is needed due to all day events which are stored in UTC. The additional events in the result list not
    // matching the time period have to be removed by caller!
    Date startDate = filter.getStartDate();
    if (startDate != null) {
        startDate = new Date(startDate.getTime() - ONE_DAY);
    }
    Date endDate = filter.getEndDate();
    if (endDate != null) {
        endDate = new Date(endDate.getTime() + ONE_DAY);
    }
    // limit events to load to chosen date view.
    if (startDate != null && endDate != null) {
        if (filter.isOnlyRecurrence() == false) {
            queryFilter.add(Restrictions.or(
                    (Restrictions.or(Restrictions.between("startDate", startDate, endDate),
                            Restrictions.between("endDate", startDate, endDate))),
                    // get events whose duration overlap with chosen duration.
                    (Restrictions.and(Restrictions.le("startDate", startDate),
                            Restrictions.ge("endDate", endDate)))));
        } else {
            queryFilter.add(
                    // "startDate" < endDate && ("recurrenceUntil" == null ||"recurrenceUnti" > startDate)
                    (Restrictions.and(Restrictions.lt("startDate", endDate),
                            Restrictions.or(Restrictions.isNull("recurrenceUntil"),
                                    Restrictions.gt("recurrenceUntil", startDate)))));
        }
    } else if (startDate != null) {
        queryFilter.add(Restrictions.ge("startDate", startDate));
    } else if (endDate != null) {
        queryFilter.add(Restrictions.le("startDate", endDate));
    }
    queryFilter.addOrder(Order.desc("startDate"));
    if (log.isDebugEnabled() == true) {
        log.debug(ToStringBuilder.reflectionToString(filter));
    }
    return queryFilter;
}

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 a  va 2s .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}/*www.java  2s. 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.config.impl.HibernateConfigItemDaoImpl.java

License:Educational Community License

@SuppressWarnings("unchecked")
@Override//from  www  .  j ava2  s .co m
public List<HibernateConfigItem> findPollOnByNode(String node, Date onOrAfter, Date before) {
    Criteria criteria = getSession().createCriteria(HibernateConfigItem.class)
            .add(Restrictions.eq("node", node));
    if (onOrAfter == null && before == null) {
        criteria.add(Restrictions.isNotNull("pollOn"));
    } else {
        if (onOrAfter != null) {
            criteria.add(Restrictions.ge("pollOn", onOrAfter));
        }
        if (before != null) {
            criteria.add(Restrictions.lt("pollOn", before));
        }
    }
    return criteria.list();
}

From source file:org.sakaiproject.contentreview.dao.ContentReviewItemDao.java

License:Educational Community License

public Optional<ContentReviewItem> findByProviderSingleItemToSubmit(Integer providerId) {

    Calendar calendar = Calendar.getInstance();

    Criteria c = sessionFactory.getCurrentSession().createCriteria(ContentReviewItem.class)
            .add(Restrictions.eq("providerId", providerId))
            .add(Restrictions.in("status",
                    new Long[] { ContentReviewConstants.CONTENT_REVIEW_NOT_SUBMITTED_CODE,
                            ContentReviewConstants.CONTENT_REVIEW_SUBMISSION_ERROR_RETRY_CODE }))
            .add(Restrictions.lt("nextRetryTime", calendar.getTime())).setMaxResults(1);

    return Optional.ofNullable((ContentReviewItem) c.uniqueResult());
}

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

License:Apache License

/**
 * Build the Criteria object here to reduce code duplication
 * @param entityClass//from  www  .  j ava  2s .  c o  m
 * @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.signup.dao.SignupMeetingDaoImpl.java

License:Educational Community License

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

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