Example usage for org.hibernate.criterion Restrictions le

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

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

Introduction

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

Prototype

public static SimpleExpression le(String propertyName, Object value)

Source Link

Document

Apply a "less than or equal" constraint to the named property

Usage

From source file:de.tuclausthal.submissioninterface.persistence.dao.impl.SimilarityTestDAO.java

License:Open Source License

@Override
public SimilarityTest takeSimilarityTest() {
    Session session = getSession();/*from ww w . ja va 2s  .c  o m*/
    Transaction tx = session.beginTransaction();
    SimilarityTest similarityTest = (SimilarityTest) session.createCriteria(SimilarityTest.class)
            .add(Restrictions.eq("status", 1)).setLockMode(LockMode.UPGRADE).createCriteria("task")
            .add(Restrictions.le("deadline", Util.correctTimezone(new Date()))).setMaxResults(1).uniqueResult();
    if (similarityTest != null) {
        similarityTest.setStatus(2);
        session.save(similarityTest);
    }
    tx.commit();
    return similarityTest;
}

From source file:de.tuclausthal.submissioninterface.persistence.dao.impl.TestDAO.java

License:Open Source License

@Override
public Test takeTest() {
    Session session = getSession();/*from ww  w . j ava  2 s  . c  om*/
    Transaction tx = session.beginTransaction();
    Test test = (Test) session.createCriteria(Test.class).add(Restrictions.eq("forTutors", true))
            .add(Restrictions.eq("needsToRun", true)).setLockMode(LockMode.UPGRADE).createCriteria("task")
            .add(Restrictions.le("deadline", Util.correctTimezone(new Date()))).setMaxResults(1).uniqueResult();
    if (test != null) {
        test.setNeedsToRun(false);
        session.save(test);
    }
    tx.commit();
    return test;
}

From source file:dk.teachus.backend.dao.hibernate.HibernateStatisticsDAO.java

License:Apache License

@SuppressWarnings("unchecked")
@Transactional(readOnly = true)//  w  w w . ja  va  2s . c o  m
public List<PupilBooking> getAllBookings(DateMidnight fromDate, DateMidnight toDate) {
    DetachedCriteria c = DetachedCriteria.forClass(PupilBookingImpl.class);
    c.createCriteria("pupil").add(Restrictions.eq("active", true));
    c.createCriteria("teacher").add(Restrictions.eq("active", true));
    c.createCriteria("period").add(Restrictions.eq("status", Status.FINAL));
    Disjunction disjunction = Restrictions.disjunction();
    disjunction.add(Restrictions.and(Restrictions.ge("createDate", fromDate.toDateTime()),
            Restrictions.le("createDate", toDate.toDateTime())));
    disjunction.add(Restrictions.and(Restrictions.ge("updateDate", fromDate.toDateTime()),
            Restrictions.le("updateDate", toDate.toDateTime())));
    c.add(disjunction);

    c.setResultTransformer(DistinctRootEntityResultTransformer.INSTANCE);

    List<PupilBooking> bookings = getHibernateTemplate().findByCriteria(c);

    return bookings;
}

From source file:eds.component.file.FileService.java

public List<SecaFileSequence> getSequences(long fileId, long start, long end) {
    if (session == null || !session.isOpen()) {
        session = hibernateUtil.getSession();
    }//from ww w  .ja v a2  s  . c  om
    List<SecaFileSequence> results = session.createCriteria(SecaFileSequence.class)
            .add(Restrictions.eq("FILE.FILE_ID", fileId)).add(Restrictions.ge("ORIGINAL_LINE_NUM", start))
            .add(Restrictions.le("ORIGINAL_LINE_NUM", end)).list();

    return results;
}

From source file:edu.depaul.armada.dao.ContainerLogDaoHibernate.java

License:Open Source License

/**
 * Returns a List<Metric> from all of the containers with a specified ID, within a
 * a particular amount of time, and with an average of a specified field.
 * @param containerId long/* www  . jav a 2 s .com*/
 * @param periodCount int
 * @param fieldToAverage String
 * @return List<Metric>
 */
@Override
public List<Metric> findWithContainerIdAndPeriod(long containerId, int periodCount, String fieldToAverage) {
    List<Metric> metrics = new ArrayList<Metric>(periodCount);
    Calendar cal = Calendar.getInstance();
    for (int i = 0; i < periodCount; i++) {
        Date end = cal.getTime();
        int hour = cal.get(Calendar.HOUR_OF_DAY);
        cal.add(Calendar.HOUR_OF_DAY, -1);
        Date start = cal.getTime();

        Criteria criteria = newCriteria();
        criteria.createAlias("container", "container");
        criteria.add(Restrictions.eq("container.id", containerId));
        criteria.add(Restrictions.le("timestamp", end));
        criteria.add(Restrictions.gt("timestamp", start)); // we don't want overlap here
        criteria.setProjection(Projections.avg(fieldToAverage));
        Object result = criteria.uniqueResult();
        int count = (result == null) ? 0 : ((Double) result).intValue();
        Metric temp = new Metric();
        temp.setHour(hour);
        temp.setValue(count);
        metrics.add(temp);
    }
    Collections.reverse(metrics); // we want the current time to be the last hour
    return metrics;
}

From source file:edu.depaul.armada.dao.ContainerLogDaoHibernate.java

License:Open Source License

/**
 * Returns a List<Metric> from all of the containers with state fields greater-than
 * or equal to certain user defined parameters.
 * @param memThreshold long/* w  w  w  . ja  v  a 2 s. c  o  m*/
 * @param cpuThreshold long
 * @param diskThreshold long
 * @param periodCountInHours int
 * @return List<Metric>
 */
@Override
public List<Metric> getStateCounts(long memThreshold, long cpuThreshold, long diskThreshold,
        int periodCountInHours) {
    List<Metric> metrics = new ArrayList<Metric>(periodCountInHours);
    Calendar cal = Calendar.getInstance();
    for (int i = 0; i < periodCountInHours; i++) {
        Date end = cal.getTime();
        int hour = cal.get(Calendar.HOUR_OF_DAY);
        cal.add(Calendar.HOUR_OF_DAY, -1);
        Date start = cal.getTime();

        Criteria criteria = newCriteria();
        criteria.add(Restrictions.le("timestamp", end));
        criteria.add(Restrictions.gt("timestamp", start)); // we don't want overlap here
        criteria.add(Restrictions.disjunction().add(Restrictions.ge("cpuUsed", cpuThreshold))
                .add(Restrictions.ge("memUsed", memThreshold)).add(Restrictions.ge("diskUsed", diskThreshold)));
        criteria.setProjection(Projections.countDistinct("container"));
        int count = ((Long) criteria.uniqueResult()).intValue();
        Metric temp = new Metric();
        temp.setHour(hour);
        temp.setValue(count);
        metrics.add(temp);
    }
    Collections.reverse(metrics); // we want the current time to be the last hour
    return metrics;
}

From source file:edu.depaul.armada.dao.ContainerLogDaoHibernate.java

License:Open Source License

/**
 * Returns a List<Metric> from all of the containers with data within a specified
 * amount of time.//w w w. ja  v a  2 s  .c o m
 * @param periodInHours int
 * @return List<Metric>
 */
@Override
public List<Metric> getContainerCounts(int periodInHours) {
    List<Metric> metrics = new ArrayList<Metric>(periodInHours);
    Calendar cal = Calendar.getInstance();
    for (int i = 0; i < periodInHours; i++) {
        Date end = cal.getTime();
        int hour = cal.get(Calendar.HOUR_OF_DAY);
        cal.add(Calendar.HOUR_OF_DAY, -1);
        Date start = cal.getTime();

        Criteria criteria = newCriteria();
        criteria.add(Restrictions.le("timestamp", end));
        criteria.add(Restrictions.gt("timestamp", start)); // we don't want overlap here
        criteria.setProjection(Projections.countDistinct("container"));
        int count = ((Long) criteria.uniqueResult()).intValue();
        Metric temp = new Metric();
        temp.setHour(hour);
        temp.setValue(count);
        metrics.add(temp);
    }
    Collections.reverse(metrics); // we want the current time to be the last hour
    return metrics;
}

From source file:edu.monash.merc.dao.TrafficLightDAO.java

License:Open Source License

private void addChromRegionConditions(Criteria geneCriteria, TLSearchBean tlSearchBean) {
    if (tlSearchBean.isRegionProvided()) {
        long regionFrom = tlSearchBean.getRegionFrom();
        long regionTo = tlSearchBean.getRegionTo();
        if (regionFrom != 0 && regionTo != 0) {
            geneCriteria.add(Restrictions.ge("endPosition", regionFrom))
                    .add(Restrictions.le("startPosition", regionTo));
        }//w  ww.j a  va  2s  .  co  m
        if (regionFrom != 0 && regionTo == 0) {
            geneCriteria.add(Restrictions.ge("endPosition", regionFrom));
        }
        if (regionFrom == 0 && regionTo != 0) {
            geneCriteria.add(Restrictions.le("startPosition", regionTo));
        }
    }
}

From source file:edu.ucsb.eucalyptus.cloud.ws.WalrusManager.java

License:Open Source License

public ListVersionsResponseType listVersions(ListVersionsType request) throws EucalyptusCloudException {
    ListVersionsResponseType reply = (ListVersionsResponseType) request.getReply();
    String bucketName = request.getBucket();
    Context ctx = Contexts.lookup();
    Account account = ctx.getAccount();//from  w  ww. j  av a 2 s.  c  o  m
    String prefix = request.getPrefix();
    if (prefix == null) {
        prefix = "";
    }

    String keyMarker = request.getKeyMarker();
    String versionMarker = request.getVersionIdMarker();

    int maxKeys = -1;
    String maxKeysString = request.getMaxKeys();
    if (maxKeysString != null) {
        maxKeys = Integer.parseInt(maxKeysString);
    } else {
        maxKeys = WalrusProperties.MAX_KEYS;
    }

    String delimiter = request.getDelimiter();

    EntityWrapper<BucketInfo> db = EntityWrapper.get(BucketInfo.class);
    BucketInfo bucketInfo = new BucketInfo(bucketName);
    bucketInfo.setHidden(false);
    List<BucketInfo> bucketList = db.queryEscape(bucketInfo);

    Hashtable<String, PrefixEntry> prefixes = new Hashtable<String, PrefixEntry>();

    if (bucketList.size() > 0) {
        BucketInfo bucket = bucketList.get(0);
        BucketLogData logData = bucket.getLoggingEnabled() ? request.getLogData() : null;

        if (ctx.hasAdministrativePrivileges() || (bucket.canRead(account.getAccountNumber())
                && (bucket.isGlobalRead() || Lookups.checkPrivilege(PolicySpec.S3_LISTBUCKETVERSIONS,
                        PolicySpec.VENDOR_S3, PolicySpec.S3_RESOURCE_BUCKET, bucketName, null)))) {

            if (bucket.isVersioningDisabled()) {
                db.rollback();
                throw new EucalyptusCloudException("Versioning has not been enabled for bucket: " + bucketName);
            }

            if (logData != null) {
                updateLogData(bucket, logData);
                reply.setLogData(logData);
            }

            if (Contexts.lookup().hasAdministrativePrivileges()) {
                try {
                    if (bucketHasSnapshots(bucketName)) {
                        db.rollback();
                        throw new NoSuchBucketException(bucketName);
                    }
                } catch (Exception e) {
                    db.rollback();
                    throw new EucalyptusCloudException(e);
                }
            }

            reply.setName(bucketName);
            reply.setIsTruncated(false);
            reply.setPrefix(prefix);
            if (maxKeys >= 0) {
                reply.setMaxKeys(maxKeys);
            }
            if (delimiter != null) {
                reply.setDelimiter(delimiter);
            }
            if (maxKeys == 0) {
                //No keys requested, so just return
                reply.setVersions(new ArrayList<VersionEntry>());
                db.commit();
                return reply;
            }

            final int queryStrideSize = maxKeys + 1;
            EntityWrapper<ObjectInfo> dbObject = db.recast(ObjectInfo.class);

            ObjectInfo searchObj = new ObjectInfo();
            searchObj.setBucketName(bucketName);
            //searchObj.setLast(true);
            searchObj.setDeleted(false);

            Criteria objCriteria = dbObject.createCriteria(ObjectInfo.class);
            objCriteria.add(Example.create(searchObj));
            objCriteria.addOrder(Order.asc("objectKey"));
            objCriteria.addOrder(Order.desc("lastModified"));
            objCriteria.setMaxResults(queryStrideSize); //add one to, hopefully, indicate truncation in one call                                    

            if (keyMarker != null) {
                if (versionMarker != null) {
                    Date resumeDate = null;
                    try {
                        ObjectInfo markerObj = new ObjectInfo();
                        markerObj.setBucketName(bucketName);
                        markerObj.setVersionId(versionMarker);
                        markerObj.setObjectKey(keyMarker);
                        ObjectInfo lastFromPrevObj = dbObject.uniqueResultEscape(markerObj);
                        if (lastFromPrevObj != null && lastFromPrevObj.getLastModified() != null) {
                            resumeDate = lastFromPrevObj.getLastModified();
                        } else {
                            throw new NoSuchEntityException("VersionIDMarker " + versionMarker
                                    + " does not match an existing object version");
                        }
                    } catch (TransactionException e) {
                        LOG.error(e);
                        dbObject.rollback();
                        throw new EucalyptusCloudException("Next-Key-Marker or Next-Version-Id marker invalid");
                    }
                    objCriteria.add(Restrictions.or(
                            Restrictions.and(Restrictions.ge("objectKey", keyMarker),
                                    Restrictions.le("lastModified", resumeDate)),
                            Restrictions.gt("objectKey", keyMarker)));
                } else {
                    objCriteria.add(Restrictions.ge("objectKey", keyMarker));
                }
            }

            if (prefix != null && !prefix.equals("")) {
                objCriteria.add(Restrictions.like("objectKey", prefix, MatchMode.START));
            }

            List<ObjectInfo> objectInfos = null;
            int resultKeyCount = 0;
            String objectKey = null;
            String[] parts = null;
            String prefixString = null;
            ArrayList<VersionEntry> versions = new ArrayList<VersionEntry>(); //contents for reply
            ArrayList<DeleteMarkerEntry> deleteMarkers = new ArrayList<DeleteMarkerEntry>(); //delete markers for reply                  

            //Iterate over result sets of size maxkeys + 1
            do {
                objectKey = null;
                parts = null;
                prefixString = null;
                if (resultKeyCount > 0) { //Start from end of last round-trip if necessary
                    objCriteria.setFirstResult(queryStrideSize);
                }

                objectInfos = (List<ObjectInfo>) objCriteria.list();

                if (objectInfos.size() > 0) {
                    for (ObjectInfo objectInfo : objectInfos) {
                        objectKey = objectInfo.getObjectKey();

                        //Look for Delete markers
                        if (objectInfo.getDeleted()) {
                            //
                        }

                        //Check if it will get aggregated as a commonprefix
                        if (delimiter != null) {
                            parts = objectKey.substring(prefix.length()).split(delimiter);
                            if (parts.length > 1) {
                                prefixString = parts[0] + delimiter;
                                if (!prefixes.containsKey(prefixString)) {
                                    if (resultKeyCount == maxKeys) {
                                        //This is a new record, so we know we're truncating if this is true
                                        reply.setNextKeyMarker(objectKey);
                                        reply.setNextVersionIdMarker(objectInfo.getVersionId());
                                        reply.setIsTruncated(true);
                                        resultKeyCount++;
                                        break;
                                    }

                                    prefixes.put(prefixString, new PrefixEntry(prefixString));
                                    resultKeyCount++; //count the unique commonprefix as a single return entry                                 
                                }
                                continue;
                            }
                        }

                        if (resultKeyCount == maxKeys) {
                            //This is a new (non-commonprefix) record, so we know we're truncating
                            reply.setNextKeyMarker(objectKey);
                            reply.setNextVersionIdMarker(objectInfo.getVersionId());
                            reply.setIsTruncated(true);
                            resultKeyCount++;
                            break;
                        }

                        if (!objectInfo.getDeleted()) {
                            VersionEntry versionEntry = new VersionEntry();
                            versionEntry.setKey(objectKey);
                            versionEntry.setVersionId(objectInfo.getVersionId());
                            versionEntry.setEtag(objectInfo.getEtag());
                            versionEntry
                                    .setLastModified(DateUtils.format(objectInfo.getLastModified().getTime(),
                                            DateUtils.ISO8601_DATETIME_PATTERN) + ".000Z");
                            try {
                                String displayName = Accounts.lookupAccountById(objectInfo.getOwnerId())
                                        .getName();
                                versionEntry
                                        .setOwner(new CanonicalUserType(objectInfo.getOwnerId(), displayName));

                            } catch (AuthException e) {
                                db.rollback();
                                throw new AccessDeniedException("Bucket", bucketName, logData);
                            }
                            versionEntry.setSize(objectInfo.getSize());
                            versionEntry.setStorageClass(objectInfo.getStorageClass());
                            versionEntry.setIsLatest(objectInfo.getLast());
                            versions.add(versionEntry);
                        } else {
                            DeleteMarkerEntry deleteMarkerEntry = new DeleteMarkerEntry();
                            deleteMarkerEntry.setKey(objectKey);
                            deleteMarkerEntry.setVersionId(objectInfo.getVersionId());
                            deleteMarkerEntry
                                    .setLastModified(DateUtils.format(objectInfo.getLastModified().getTime(),
                                            DateUtils.ISO8601_DATETIME_PATTERN) + ".000Z");

                            try {
                                String ownerId = objectInfo.getOwnerId();
                                String displayName = Accounts.lookupAccountById(ownerId).getName();
                                deleteMarkerEntry.setOwner(new CanonicalUserType(ownerId, displayName));
                            } catch (AuthException e) {
                                db.rollback();
                                throw new AccessDeniedException("Bucket", bucketName, logData);
                            }
                            deleteMarkerEntry.setIsLatest(objectInfo.getLast());
                            deleteMarkers.add(deleteMarkerEntry);
                        }

                        resultKeyCount++;
                    }
                }
                if (resultKeyCount <= maxKeys && objectInfos.size() <= maxKeys) {
                    break;
                }
            } while (resultKeyCount <= maxKeys);

            reply.setDeleteMarkers(deleteMarkers);
            reply.setVersions(versions);

            //Sort the prefixes from the hashtable and add to the reply
            if (prefixes != null && prefixes.size() > 0) {
                ArrayList<PrefixEntry> prefixList = new ArrayList<PrefixEntry>();
                prefixList.addAll(prefixes.values());

                Collections.sort(prefixList, new Comparator<PrefixEntry>() {
                    public int compare(PrefixEntry e1, PrefixEntry e2) {
                        return e1.getPrefix().compareTo(e2.getPrefix());
                    }
                });
                reply.setCommonPrefixes(prefixList);
            }

        } else {
            db.rollback();
            throw new AccessDeniedException("Bucket", bucketName, logData);
        }
    } else {
        db.rollback();
        throw new NoSuchBucketException(bucketName);
    }
    db.commit();
    return reply;
}

From source file:edu.uoc.dao.impl.MeetingRoomDaoImpl.java

@Override
public List<MeetingRoom> findbyForm(SearchMeeting searchMeeting, List<Room> ids_room) {

    String topic = searchMeeting.getTopic();
    Room room = searchMeeting.getRoom();

    //Convert TimeStamp to Date
    Timestamp tsStart = Util.converToTimestamp(searchMeeting.getStart_meeting(), logger);
    Timestamp tsEnd = Util.converToTimestamp(searchMeeting.getEnd_meeting(), logger);

    Criteria criteria;//from  w ww . ja v  a  2s .c  om
    criteria = this.getSession().createCriteria(MeetingRoom.class, "meeting");
    criteria.add(Restrictions.eq("meeting.finished", (byte) 1));
    criteria.add(Restrictions.eq("meeting.recorded", (byte) 1));
    if (tsStart != null) {
        criteria.add(Restrictions.ge("meeting.start_meeting", tsStart));
    }
    if (tsEnd != null) {
        criteria.add(Restrictions.le("meeting.end_meeting", tsEnd));
    }
    if (topic != null && topic.length() > 0) {
        criteria.add(Restrictions.like("meeting.topic", "%" + topic + "%"));
    }
    if (room != null && room.getId() > 0) {
        criteria.add(Restrictions.eq("meeting.id_room", room));
    } else {
        criteria.add(Restrictions.in("meeting.id_room", ids_room));
    }
    if (searchMeeting.getParticipants() != null && searchMeeting.getParticipants().length() > 0) {
        DetachedCriteria subCriteria = DetachedCriteria.forClass(UserMeeting.class, "userMeeting");
        subCriteria.createAlias("userMeeting.pk.meeting", "userMeeting.id");
        subCriteria.setProjection(Projections.projectionList().add(Projections.property("userMeeting.id")));
        subCriteria.add(Restrictions.eqProperty("meeting.id", "userMeeting.id"));

        DetachedCriteria subCriteriaUser = DetachedCriteria.forClass(User.class, "user");
        subCriteriaUser.setProjection(Projections.projectionList().add(Projections.property("user.id")));
        subCriteriaUser.add(Restrictions.like("user.fullname", "%" + searchMeeting.getParticipants() + "%"));
        subCriteriaUser.add(Restrictions.eqProperty("user.id", "userMeeting.pk.user.id"));
        subCriteria.add(Subqueries.exists(subCriteriaUser));
        criteria.add(Subqueries.exists(subCriteria));
    }
    logger.info("Criteria " + criteria.toString());

    return criteria.list();
}