Example usage for org.hibernate.criterion Restrictions eq

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

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

Introduction

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

Prototype

public static SimpleExpression eq(String propertyName, Object value)

Source Link

Document

Apply an "equal" constraint to the named property

Usage

From source file:au.edu.uts.eng.remotelabs.schedserver.bookings.pojo.impl.BookingsServiceImpl.java

License:Open Source License

@Override
public BookingOperation createBooking(Calendar start, Calendar end, User user, ResourcePermission perm,
        Session db) {//from  w w w  . j av  a 2 s  .  c  om
    BookingOperation response = new BookingOperation();
    response.setSuccess(false);

    /* ----------------------------------------------------------------
     * -- Check permission constraints.                              --
     * ---------------------------------------------------------------- */
    Date startDate = start.getTime();
    Date endDate = end.getTime();

    if (!perm.getUserClass().isBookable()) {
        this.logger.info(
                "Unable to create a booking because the permission " + perm.getId() + " is not bookable.");
        response.setFailureReason("Permission not bookable.");
        return response;
    }

    if (startDate.before(perm.getStartTime()) || endDate.after(perm.getExpiryTime())) {
        this.logger.info("Unable to create a booking because the booking time is outside the permission time. "
                + "Permission start: " + perm.getStartTime() + ", expiry: " + perm.getExpiryTime()
                + ", booking start: " + startDate + ", booking end: " + endDate + '.');
        response.setFailureReason("Booking time out of permission range.");
        return response;
    }

    /* Time horizon is a moving offset when bookings can be made. */
    Calendar horizon = Calendar.getInstance();
    horizon.add(Calendar.SECOND, perm.getUserClass().getTimeHorizon());
    if (horizon.after(start)) {
        this.logger.info("Unable to create a booking because the booking start time (" + startDate
                + ") is before the time horizon (" + horizon.getTime() + ").");
        response.setFailureReason("Before time horizon.");
        return response;
    }

    /* Maximum concurrent bookings. */
    int numBookings = (Integer) db.createCriteria(Bookings.class).add(Restrictions.eq("active", Boolean.TRUE))
            .add(Restrictions.eq("user", user)).add(Restrictions.eq("resourcePermission", perm))
            .setProjection(Projections.rowCount()).uniqueResult();
    if (numBookings >= perm.getMaximumBookings()) {
        this.logger.info("Unable to create a booking because the user " + user.getNamespace() + ':'
                + user.getName() + " already has the maxiumum numnber of bookings (" + numBookings + ").");
        response.setFailureReason("User has maximum number of bookings.");
        return response;
    }

    /* User bookings at the same time. */
    numBookings = (Integer) db.createCriteria(Bookings.class).setProjection(Projections.rowCount())
            .add(Restrictions.eq("active", Boolean.TRUE)).add(Restrictions.eq("user", user))
            .add(Restrictions.disjunction()
                    .add(Restrictions.and(Restrictions.gt("startTime", startDate),
                            Restrictions.lt("startTime", endDate)))
                    .add(Restrictions.and(Restrictions.gt("endTime", startDate),
                            Restrictions.le("endTime", endDate)))
                    .add(Restrictions.and(Restrictions.le("startTime", startDate),
                            Restrictions.gt("endTime", endDate))))
            .uniqueResult();

    if (numBookings > 0) {
        this.logger.info("Unable to create a booking because the user " + user.getNamespace() + ':'
                + user.getName() + " has concurrent bookings.");
        response.setFailureReason("User has concurrent bookings.");
        return response;
    }

    /* ----------------------------------------------------------------
     * -- Create booking.                                            --
     * ---------------------------------------------------------------- */
    if (ResourcePermission.CONSUMER_PERMISSION.equals(perm.getType())) {
        CreateBookingRequest request = new CreateBookingRequest();
        if (request.createBooking(user, perm.getRemotePermission(), start, end, db)) {
            response.setSuccess(request.wasSuccessful());
            response.setFailureReason(request.getReason());
            if (request.wasSuccessful()) {
                /* Provider created booking so we now need to create it 
                 * locally. */
                this.logger.debug("Successfullly created booking at provider with identifier "
                        + request.getBookingID() + '.');
                Bookings bk = new Bookings();
                bk.setActive(true);
                bk.setStartTime(startDate);
                bk.setEndTime(endDate);
                bk.setDuration((int) (end.getTimeInMillis() - start.getTimeInMillis()) / 1000);
                bk.setResourcePermission(perm);
                bk.setResourceType(ResourcePermission.CONSUMER_PERMISSION);
                bk.setProviderId(request.getBookingID());
                bk.setUser(user);
                bk.setUserNamespace(user.getNamespace());
                bk.setUserName(user.getName());
                response.setBooking(new BookingsDao(db).persist(bk));

                /* Notification emails are only sent to home users. */
                new BookingNotification(bk).notifyCreation();
            } else {
                this.logger.info("Provider failed to create booking with reason " + request.getReason());

                /* Provider returned that it couldn't create booking. */
                for (BookingTime bt : request.getBestFits()) {
                    response.addBestFit(bt.getStart(), bt.getEnd());
                }
            }
        } else {
            /* Provider call failed. */
            this.logger
                    .info("Provider call to create booking failed with reason " + request.getFailureReason());
            response.setSuccess(false);
            response.setFailureReason("Provider request failed (" + request.getFailureReason() + ")");
        }
    } else {
        BookingCreation bc = this.engine.createBooking(user, perm, new TimePeriod(start, end), db);
        if (bc.wasCreated()) {
            response.setSuccess(true);
            response.setBooking(bc.getBooking());

            /* Notification emails are only sent to home users. */
            if (perm.getRemotePermission() == null)
                new BookingNotification(bc.getBooking()).notifyCreation();
        } else {
            response.setSuccess(false);
            response.setFailureReason("Resource not free.");

            for (TimePeriod tp : bc.getBestFits()) {
                numBookings = (Integer) db.createCriteria(Bookings.class).setProjection(Projections.rowCount())
                        .add(Restrictions.eq("active", Boolean.TRUE)).add(Restrictions.eq("user", user))
                        .add(Restrictions.disjunction()
                                .add(Restrictions.and(Restrictions.gt("startTime", tp.getStartTime().getTime()),
                                        Restrictions.lt("startTime", tp.getEndTime().getTime())))
                                .add(Restrictions.and(Restrictions.gt("endTime", tp.getStartTime().getTime()),
                                        Restrictions.le("endTime", tp.getEndTime().getTime())))
                                .add(Restrictions.and(Restrictions.le("startTime", tp.getStartTime().getTime()),
                                        Restrictions.gt("endTime", tp.getEndTime().getTime()))))
                        .uniqueResult();
                if (numBookings > 0) {
                    this.logger.debug("Excluding best fit option for user " + user.qName() + " because it is "
                            + "concurrent with an existing.");
                    continue;
                }

                response.addBestFit(tp.getStartTime(), tp.getEndTime());
            }
        }
    }

    return response;
}

From source file:au.edu.uts.eng.remotelabs.schedserver.dataaccess.dao.AcademicPermissionDao.java

License:Open Source License

/**
 * Gets all the academic permissions for the specified user. 
 * /*w  w  w .  j  a v  a2  s.  c o  m*/
 * @param user user to find permissions for 
 * @return list of academic permissions 
 */
@SuppressWarnings("unchecked")
public List<AcademicPermission> getByUser(User user) {
    Criteria cri = this.session.createCriteria(AcademicPermission.class);
    cri.add(Restrictions.eq("user", user));
    return cri.list();
}

From source file:au.edu.uts.eng.remotelabs.schedserver.dataaccess.dao.AcademicPermissionDao.java

License:Open Source License

/**
 * Gets all the academic permissions for the specified user class.
 * /*  w  w  w  .  j  a v  a  2 s  .c o  m*/
 * @param uClass user class to find permissions for
 * @return list of academic permissions 
 */
@SuppressWarnings("unchecked")
public List<AcademicPermission> getByUserClass(UserClass uClass) {
    Criteria cri = this.session.createCriteria(AcademicPermission.class);
    cri.add(Restrictions.eq("userClass", uClass));
    return cri.list();
}

From source file:au.edu.uts.eng.remotelabs.schedserver.dataaccess.dao.AcademicPermissionDao.java

License:Open Source License

/**
 * Gets the academic permission for the specified user and user class. If it is
 * not found <code>null</code>. If more than one permission is found, the first
 * is used.//from   ww  w . j  a va  2  s. c o  m
 * 
 * @param user user constraint
 * @param uClass user class constraint
 * @return permission or <code>null</code>
 */
@SuppressWarnings("unchecked")
public AcademicPermission getForUserAndUserClass(User user, UserClass uClass) {
    Criteria cri = this.session.createCriteria(AcademicPermission.class);
    cri.add(Restrictions.eq("user", user)).add(Restrictions.eq("userClass", uClass));

    List<AcademicPermission> perms = cri.list();
    if (perms.size() == 0) {
        return null;
    } else if (perms.size() > 1) {
        this.logger.warn("Found more than one academic permission for the user " + user.getName() + " and "
                + "user class " + uClass.getName() + ". Using the first found permission.");
    }
    return perms.get(0);
}

From source file:au.edu.uts.eng.remotelabs.schedserver.dataaccess.dao.ConfigDao.java

License:Open Source License

/**
 * Returns the configuration values with the specified configuration key.
 * //from  ww  w.java 2 s . c  o m
 * @param key configuration key
 * @return list of matching configuration values
 */
@SuppressWarnings("unchecked")
public List<Config> getConfig(String key) {
    Criteria crit = this.session.createCriteria(this.clazz);
    crit.add(Restrictions.eq("key", key));
    return crit.list();
}

From source file:au.edu.uts.eng.remotelabs.schedserver.dataaccess.dao.ProjectDao.java

License:Open Source License

/**
 * Gets the latest created project that is related to the specified 
 * session. //  w  ww  .  ja va 2 s.c o  m
 * 
 * @param session session to find the session from
 * @param autogenerate whether the project is set to auto generate 
 * @return project or null if no project exists
 */
public Project getLatestProject(Session session, boolean autogenerate) {
    return (Project) this.session.createCriteria(Project.class).add(Restrictions.eq("user", session.getUser())) // User constraint
            .add(Restrictions.eq("userClass", session.getResourcePermission().getUserClass())) // User class constraint
            .add(Restrictions.eq("autoPublishCollections", autogenerate)).addOrder(Order.desc("creationTime"))
            .setMaxResults(1).uniqueResult();
}

From source file:au.edu.uts.eng.remotelabs.schedserver.dataaccess.dao.RemotePermissionDao.java

License:Open Source License

/**
 * Finds the remote permission with the specified GUID.
 * //from  www .j  a va 2 s  .  co m
 * @param guid guid to find remote perission with
 * @return remote permission or <tt>null</tt> if not found
 */
public RemotePermission findByGuid(String guid) {
    return (RemotePermission) this.session.createCriteria(RemotePermission.class)
            .add(Restrictions.eq("guid", guid)).uniqueResult();
}

From source file:au.edu.uts.eng.remotelabs.schedserver.dataaccess.dao.RemoteSiteDao.java

License:Open Source License

public RemoteSite findSite(String guid) {
    return (RemoteSite) this.session.createCriteria(RemoteSite.class).add(Restrictions.eq("guid", guid))
            .uniqueResult();// w  w  w . j  av  a2 s .c  o m
}

From source file:au.edu.uts.eng.remotelabs.schedserver.dataaccess.dao.RequestablePermissionPeriodDao.java

License:Open Source License

/**
 * Gets the list of active requestable periods.
 * /*from   w ww  . j av  a2s  .  c  om*/
 * @return list of requestable periods
 */
@SuppressWarnings("unchecked")
public List<RequestablePermissionPeriod> getActivePeriods() {
    return this.session.createCriteria(RequestablePermissionPeriod.class)
            .add(Restrictions.eq("active", Boolean.TRUE)).add(Restrictions.gt("end", new Date()))
            .addOrder(Order.desc("type")).addOrder(Order.desc("rigType")).addOrder(Order.desc("rig"))
            .addOrder(Order.desc("requestCapabilities")).addOrder(Order.asc("start")).list();
}

From source file:au.edu.uts.eng.remotelabs.schedserver.dataaccess.dao.RequestCapabilitiesDao.java

License:Open Source License

/**
 * Find the request capabilities entity which match the specified capabilities.
 * <code>null</code> is returned if none is found.
 *  //  w ww .j  a va2 s .c om
 * @param capabilities capabilities to find 
 * @return capabilities or null
 */
public RequestCapabilities findCapabilites(String capabilities) {
    Criteria cri = this.session.createCriteria(RequestCapabilities.class);
    cri.add(Restrictions.eq("capabilities", new Capabilities(capabilities).asCapabilitiesString()));
    return (RequestCapabilities) cri.uniqueResult();
}