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:TechGuideExamples.java

License:BSD License

public static void main(String[] args) throws Exception {

    System.out.println("*** Tech Guide Examples");

    ApplicationService appService = ApplicationServiceProvider.getApplicationService();

    /** Examples used in Developer Guide */

    try {/*from www  .java2 s .  c o m*/
        System.out.println("\nExample One: Simple Search (Single Criteria Object)");
        Gene gene = new Gene();
        // searching for all genes whose symbol starts with brca
        gene.setSymbol("brca*");

        List resultList = appService.search(Gene.class, gene);

        for (Iterator resultsIterator = resultList.iterator(); resultsIterator.hasNext();) {
            Gene returnedGene = (Gene) resultsIterator.next();
            System.out.println("Symbol: " + returnedGene.getSymbol() + "\tTaxon:"
                    + returnedGene.getTaxon().getScientificName() + "\tName " + returnedGene.getFullName());
        }
    } catch (RuntimeException e) {
        e.printStackTrace();
    }

    try {
        System.out.println("\nExample Two: Simple Search (Criteria Object Collection)");
        Taxon taxon1 = new Taxon();
        taxon1.setAbbreviation("hs"); // Homo sapiens
        Taxon taxon2 = new Taxon();
        taxon2.setAbbreviation("m"); // Mus musculus
        List<Taxon> taxonList = new ArrayList<Taxon>();
        taxonList.add(taxon1);
        taxonList.add(taxon2);
        List resultList = appService.search(Gene.class, taxonList);
        System.out.println("Total # of records = " + resultList.size());

    } catch (Exception e) {
        e.printStackTrace();
    }

    try {
        System.out.println("\nExample Three: Simple Search (Compound Criteria Object)");
        Taxon taxon = new Taxon();
        taxon.setAbbreviation("hs"); // Homo sapiens
        Gene gene = new Gene();
        gene.setTaxon(taxon);
        gene.setSymbol("IL5"); // Interleukin 5
        List<Gene> geneList = new ArrayList<Gene>();
        geneList.add(gene);
        Pathway pathway = new Pathway();
        pathway.setGeneCollection(geneList);
        List resultList = appService.search("gov.nih.nci.cabio.domain.Pathway", pathway);
        for (Iterator resultsIterator = resultList.iterator(); resultsIterator.hasNext();) {
            Pathway returnedPathway = (Pathway) resultsIterator.next();
            System.out.println("Name: " + returnedPathway.getName() + "\tDisplayValue: "
                    + returnedPathway.getDisplayValue());
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

    try {
        System.out.println("\nExample Four: Nested Search");
        Gene gene = new Gene();
        gene.setSymbol("TP53"); // Tumor protein p53 (Li-Fraumeni syndrome)   
        List resultList = appService
                .search("gov.nih.nci.cabio.domain.ProteinSequence,gov.nih.nci.cabio.domain.Protein", gene);
        for (Iterator resultsIterator = resultList.iterator(); resultsIterator.hasNext();) {
            ProteinSequence returnedProtSeq = (ProteinSequence) resultsIterator.next();
            System.out.println("Id: " + returnedProtSeq.getId() + "\tLength: " + returnedProtSeq.getLength());
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

    try {
        System.out.println("\nExample Five: Detached Criteria Search");
        DetachedCriteria criteria = DetachedCriteria.forClass(PhysicalLocation.class);
        criteria = criteria.add(Restrictions.gt("chromosomalStartPosition", new Long(86851632)));
        criteria = criteria.add(Restrictions.lt("chromosomalEndPosition", new Long(86861632)));
        criteria = criteria.add(Restrictions.ilike("assembly", "reference"));
        criteria = criteria.createCriteria("chromosome").add(Restrictions.eq("number", "1"));
        List resultList = appService.query(criteria);
        System.out.println("Total # of  records = " + resultList.size());
    } catch (Exception e) {
        e.printStackTrace();
    }

    try {
        System.out.println("\nExample Six: HQL Search");
        String hqlString = "FROM gov.nih.nci.cabio.domain.Gene g WHERE g.symbol LIKE ?";
        List<String> params = new ArrayList<String>();
        params.add("BRCA%");
        HQLCriteria hqlC = new HQLCriteria(hqlString, params);
        List resultList = appService.query(hqlC);
        System.out.println("Total # of records = " + resultList.size());
    } catch (Exception e) {
        e.printStackTrace();
    }

}

From source file:TestClientWithTimestamps.java

License:BSD License

@SuppressWarnings({ "unused", "unchecked" })
private static void searchGeneBiomarker() {
    /*/*from  w ww. j  a  v a 2s  . co m*/
     * This example demonstrates the use of Hibernate detached criteria
     * objects to formulate and perform more sophisticated searches. A
     * detailed description of detached criteria is beyond the scope of this
     * example; for more information, please consult the Hibernate
     * documentation at
     * http://www.hibernate.org/hib_docs/v3/api/org/hibernate/criterion/DetachedCriteria.html
     */

    DetachedCriteria criteria = DetachedCriteria.forClass(GeneBiomarker.class);
    criteria.add(Restrictions.gt("startPhyscialLocation", new Long(6000000)));
    criteria.add(Restrictions.lt("endPhysicalLocation", new Long(6300000)));
    criteria.add(Restrictions.eq("chromosome", "19"));

    try {
        System.out.println("______________________________________________________________________");
        System.out.println("Retrieving all GeneBiomarker objects for Chr 19,6000000 - 6300000");
        ApplicationService appService = ApplicationServiceProvider.getApplicationService();

        List resultList = appService.query(criteria, GeneBiomarker.class.getName());
        if (resultList != null) {
            System.out.println("Number of results returned: " + resultList.size());
            System.out.println("ChromosomeName" + "\t" + "StartPhyscialLocation" + "\t" + "EndPhysicalLocation"
                    + "\t" + "HugoGeneSymbol" + "\n");
            for (Iterator resultsIterator = resultList.iterator(); resultsIterator.hasNext();) {
                GeneBiomarker returnedObj = (GeneBiomarker) resultsIterator.next();
                System.out.println(returnedObj.getChromosome() + "\t" + returnedObj.getStartPhyscialLocation()
                        + "\t" + returnedObj.getEndPhysicalLocation() + "\t" + returnedObj.getHugoGeneSymbol()
                        + "\n");
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:alma.acs.tmcdb.TestPojosPersistence.java

License:Open Source License

public void testCriteriaAPI() throws Exception {

    createDB();/*from  ww w  .  ja  va 2 s .  c  o m*/

    try {
        createConfigurationComputerAndTwoNetworkDevices();

        Configuration config = (Configuration) hibernateUtil.getList(Configuration.class).iterator().next();
        assertNotNull(config);

        // Now we test that using the criteria API we can find our objects
        Criteria c = hibernateUtil.getSession().createCriteria(NetworkDevice.class);
        c.add(Restrictions.eq("name", "wall-e"));
        assertEquals(2, c.list().size());

        c = hibernateUtil.getSession().createCriteria(NetworkDevice.class);
        c.add(Restrictions.eq("name", "wall-e"));
        c.add(Restrictions.eq("networkName", "wall-e.eso.org"));
        assertEquals(1, c.list().size());

        c = hibernateUtil.getSession().createCriteria(NetworkDevice.class);
        c.add(Restrictions.eq("configuration", config));
        assertEquals(3, c.list().size());

        c = hibernateUtil.getSession().createCriteria(Configuration.class);
        c.add(Restrictions.eq("configurationName", "rtobarConfig"));
        c.add(Restrictions.lt("creationTime", new Date()));
        assertEquals(1, c.list().size());

        try {
            c = hibernateUtil.getSession().createCriteria(Configuration.class);
            c.add(Restrictions.eq("configuratioName", "rtobarConfig")); // typo: should be configurationName
            c.list();
            fail("Should fail, property 'configuratioName' doesn't exist for Configuration objects");
        } catch (QueryException e) {
        }

    } finally {
        dropDB();
    }

}

From source file:analysers.MarketValueAnalyser.java

License:Open Source License

public List<Double> createMarginalDistribution(double lower, double upper, int days,
        MarketValueAnalyser.Analyse period, boolean good_rep, PrintWriter writer) {

    HibernateSupport.beginTransaction();
    Criteria c2 = HibernateSupport.getCurrentSession().createCriteria(News.class);
    c2.createAlias("news_details", "detail");
    c2.add(Restrictions.ge("detail.total_polarity", lower));
    c2.add(Restrictions.lt("detail.total_polarity", upper));

    if (good_rep) {
        c2.createAlias("companies", "company");
        c2.add(News.getNewsOfCompaniesWithGoodReputation());
    }/* w w  w . j a  v  a 2 s  .co m*/

    List<News> news_list = c2.list();
    HibernateSupport.commitTransaction();

    System.out.println("list.size() = " + news_list.size());

    PolynomialSplineFunction psf;
    Date publish_date;
    Calendar from = Calendar.getInstance();
    Calendar to = Calendar.getInstance();
    double[] share_price_dev;
    int counter = 0;
    News single_news;
    List<Company> companies;
    List<Double> price_devs_period = new ArrayList<Double>();
    Pair<Calendar, Calendar> from_to;

    while (news_list.size() > 0) {
        single_news = news_list.get(0);
        news_list.remove(0);

        companies = single_news.getCompaniesNew();

        publish_date = single_news.getDate();
        //from.setTime(publish_date);
        //to.setTime(publish_date);

        from_to = MyDateUtils.getFromToCalendars(period, publish_date, days);
        from = from_to.getValue0();
        to = from_to.getValue1();

        to.set(Calendar.DAY_OF_YEAR, to.get(Calendar.DAY_OF_YEAR) + days);
        for (Company company : single_news.getCompaniesNew()) {
            //System.out.println("publish_date = " + publish_date);
            //System.out.println("ISIN = " + company.getIsin());
            if ((psf = this.getMarketValueSplineFromTo(company, from, to)) != null) {
                share_price_dev = this.getSharePriceDevelopement(psf, from, to);
                //System.out.println(++counter);
                //System.out.println(share_price_dev[days - 1]);
                price_devs_period.add(share_price_dev[days - 1]); //day - 1
                writer.println(single_news.getNewsDetails().get(0).getTotalPolarity() + ", "
                        + share_price_dev[days - 1]);
            }
        }
    }

    /*Collections.sort(price_devs_period);
    List<Double> data_set = this.createDataSet(price_devs_period, -10.0f, 10.0f, 42);
    System.out.println(data_set);
    return data_set;*/
    return null;

}

From source file:ar.com.zauber.commons.repository.query.visitor.CriteriaFilterVisitor.java

License:Apache License

/** calculate a criterion */
private Criterion createCriterion(final BinaryPropertyFilter binaryPropertyFilter, final Object value) {
    final String fieldName = getFieldName(binaryPropertyFilter.getProperty());
    final Criterion ret;

    if (binaryPropertyFilter instanceof EqualsPropertyFilter) {
        ret = Restrictions.eq(fieldName, value);
    } else if (binaryPropertyFilter instanceof LessThanPropertyFilter) {
        ret = Restrictions.lt(fieldName, value);
    } else if (binaryPropertyFilter instanceof LessThanEqualsPropertyFilter) {
        ret = Restrictions.le(fieldName, value);
    } else if (binaryPropertyFilter instanceof GreaterThanPropertyFilter) {
        ret = Restrictions.gt(fieldName, value);
    } else if (binaryPropertyFilter instanceof GreaterThanEqualsPropertyFilter) {
        ret = Restrictions.ge(fieldName, value);
    } else if (binaryPropertyFilter instanceof LikePropertyFilter) {
        if (((LikePropertyFilter) binaryPropertyFilter).getCaseSensitive()) {
            ret = Restrictions.like(fieldName, value);
        } else {/*w w  w.j  a v a2s. co  m*/
            ret = Restrictions.ilike(fieldName, value);
        }
    } else {
        throw new IllegalStateException("Unable to process filter" + binaryPropertyFilter);
    }

    return ret;
}

From source file:au.edu.uts.eng.remotelabs.schedserver.bookings.impl.slotsengine.DayBookings.java

License:Open Source License

/**
 * Adds a day range constraint to a bookings query so that bookings within
 * this day are returned.// ww  w .  j  av a2s.c  o m
 * 
 * @return restriction
 */
private Criterion addDayRange() {
    return Restrictions.disjunction().add(Restrictions.and( // Booking within day
            Restrictions.ge("startTime", this.dayBegin), Restrictions.le("endTime", this.dayEnd)))
            .add(Restrictions.and( // Booking starts before day and ends on this day
                    Restrictions.lt("startTime", this.dayBegin), Restrictions.gt("endTime", this.dayBegin)))
            .add(Restrictions.and( // Booking starts on day and ends after day
                    Restrictions.lt("startTime", this.dayEnd), Restrictions.gt("endTime", this.dayEnd)))
            .add(Restrictions.and(Restrictions.le("startTime", this.dayBegin),
                    Restrictions.gt("endTime", this.dayEnd)));
}

From source file:au.edu.uts.eng.remotelabs.schedserver.bookings.impl.slotsengine.SlotBookingEngine.java

License:Open Source License

@Override
public synchronized BookingInit init() {
    this.logger.debug("Initalising the slot booking engine...");

    Calendar today = Calendar.getInstance();

    /* Cancel all bookings in the past. */
    Session db = DataAccessActivator.getNewSession();
    @SuppressWarnings("unchecked")
    List<Bookings> bookings = db.createCriteria(Bookings.class).add(Restrictions.eq("active", Boolean.TRUE))
            .add(Restrictions.lt("endTime", today.getTime())).list();
    for (Bookings bk : bookings) {
        this.logger.warn("Cancelling booking (" + bk.getId() + ") which expired when the Scheduling Server "
                + "was not running for user " + bk.getUser().qName() + " which expired on " + bk.getEndTime()
                + '.');
        bk.setActive(false);//from w ww.  j  a v a  2 s .co m
        bk.setCancelReason("Expired when Scheduling Server was not running.");

        new BookingNotification(bk).notifyCancel();
    }
    if (bookings.size() > 0) {
        db.beginTransaction();
        db.flush();
        db.getTransaction().commit();
    }

    /* Load up the current day bookings. */
    DayBookings day = this.getDayBookings(TimeUtil.getDayKey(today));
    day.fullLoad(db);

    /* Initalise the management tasks. */
    BookingInit init = new BookingInit();
    this.redeemer = new Redeemer(this, day);
    init.addTask(this.redeemer);
    init.addListener(this.redeemer);
    init.addListener(new RigRegisteredListener());
    init.addTask(new DayCleaner());

    return init;
}

From source file:au.edu.uts.eng.remotelabs.schedserver.bookings.intf.BookingsService.java

License:Open Source License

@Override
public CreateBookingResponse createBooking(CreateBooking createBooking) {
    /* --------------------------------------------------------------------
     * -- Read request parameters.                                       --
     * -------------------------------------------------------------------- */
    CreateBookingType request = createBooking.getCreateBooking();
    String debug = "Received " + this.getClass().getSimpleName() + "#createBooking with params: ";

    UserIDType uid = request.getUserID();
    debug += " user ID=" + uid.getUserID() + ", user namespace=" + uid.getUserNamespace() + ", user name="
            + uid.getUserName() + " user QName=" + uid.getUserQName();

    BookingType booking = request.getBooking();
    int pid = booking.getPermissionID().getPermissionID();
    debug += ", permission=" + pid;

    Calendar start = booking.getStartTime();
    Calendar end = booking.getEndTime();
    this.dstHack(start);
    this.dstHack(end);

    debug += ", start=" + start.getTime() + ", end=" + end.getTime();

    debug += ", send notification=" + request.getSendNotification() + ", notification time zone="
            + request.getNotificationTimezone() + '.';
    this.logger.debug(debug);

    /* --------------------------------------------------------------------
     * -- Generate default response parameters.                          --
     * -------------------------------------------------------------------- */
    CreateBookingResponse response = new CreateBookingResponse();
    BookingResponseType status = new BookingResponseType();
    status.setSuccess(false);/*  w  w  w.j  ava 2 s  .  c om*/
    response.setCreateBookingResponse(status);

    Session ses = DataAccessActivator.getNewSession();
    try {
        /* ----------------------------------------------------------------
         * -- Load the user.                                             --
         * ---------------------------------------------------------------- */
        User user = this.getUserFromUserID(uid, ses);
        if (user == null) {
            this.logger.info("Unable to create a booking because the user has not been found. Supplied "
                    + "credentials ID=" + uid.getUserID() + ", namespace=" + uid.getUserNamespace() + ", "
                    + "name=" + uid.getUserName() + '.');
            status.setFailureReason("User not found.");
            return response;
        }

        /* ----------------------------------------------------------------
         * -- Load the permission.                                       --
         * ---------------------------------------------------------------- */
        ResourcePermission perm = new ResourcePermissionDao(ses).get(Long.valueOf(pid));
        if (perm == null) {
            this.logger.info("Unable to create a booking because the permission has not been found. Supplied "
                    + "permission ID=" + pid + '.');
            status.setFailureReason("Permission not found.");
            return response;
        }

        if (!this.checkPermission(user, perm)) {
            this.logger.info("Unable to create a booking because the user " + user.getNamespace() + ':'
                    + user.getName() + " does not have permission " + pid + '.');
            status.setFailureReason("Does not have permission.");
            return response;
        }

        /* ----------------------------------------------------------------
         * -- 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 " + pid + " is not bookable.");
            status.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 + '.');
            status.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() + ").");
            status.setFailureReason("Before time horizon.");
            return response;
        }

        /* Maximum concurrent bookings. */
        int numBookings = (Integer) ses.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 + ").");
            status.setFailureReason("User has maximum number of bookings.");
            return response;
        }

        /* User bookings at the same time. */
        numBookings = (Integer) ses.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.");
            status.setFailureReason("User has concurrent bookings.");
            return response;
        }

        /* ----------------------------------------------------------------
         * -- Create booking.                                            --
         * ---------------------------------------------------------------- */
        BookingCreation bc = this.engine.createBooking(user, perm, new TimePeriod(start, end), ses);
        if (bc.wasCreated()) {
            status.setSuccess(true);
            BookingIDType bid = new BookingIDType();
            bid.setBookingID(bc.getBooking().getId().intValue());
            status.setBookingID(bid);

            new BookingNotification(bc.getBooking()).notifyCreation();
        } else {
            status.setSuccess(false);
            status.setFailureReason("Resource not free.");

            BookingListType bestFits = new BookingListType();
            status.setBestFits(bestFits);
            for (TimePeriod tp : bc.getBestFits()) {
                numBookings = (Integer) ses.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;
                }
                BookingType fit = new BookingType();
                fit.setPermissionID(booking.getPermissionID());
                fit.setStartTime(tp.getStartTime());
                fit.setEndTime(tp.getEndTime());
                bestFits.addBookings(fit);
            }
        }
    } finally {
        ses.close();
    }

    return response;
}

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 ww  .jav a2s .co  m*/
    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.RigLogDao.java

License:Open Source License

/**
 * Finds all the stored logs for the specified period for a specific
 * rig. The logs are ordered by their time stamp with the earliest log 
 * first.//  w  w w  .  j a v a2 s  .  c  o  m
 * 
 * @param rig rig to find the logs for
 * @param begin beginning of a period
 * @param end end of a period
 * @return list of logs
 */
@SuppressWarnings("unchecked")
public List<RigLog> findLogs(Rig rig, Date begin, Date end) {
    Criteria cri = this.session.createCriteria(RigLog.class);
    cri.add(Restrictions.eq("rig", rig));
    cri.add(Restrictions.gt("timeStamp", begin));
    cri.add(Restrictions.lt("timeStamp", end));
    cri.addOrder(Order.asc("timeStamp"));
    return cri.list();
}