Example usage for org.hibernate.criterion Projections rowCount

List of usage examples for org.hibernate.criterion Projections rowCount

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.criterion.*
  5. Projections
  6. rowCount

Introduction

In this page you can find the example usage for org.hibernate.criterion Projections rowCount.

Prototype

public static Projection rowCount()

Source Link

Document

The query row count, ie.

Usage

From source file:abid.password.swing.dao.hibernate.AbstractHibernateDao.java

License:Apache License

@SuppressWarnings("rawtypes")
public int countAll() {
    Session session = sessionFactory.openSession();
    try {//from  w  ww  . ja  va2s .c o  m
        Criteria criteria = session.createCriteria(persistentClass);
        criteria.setProjection(Projections.rowCount());

        List result = criteria.list();
        Long rowCount = (Long) result.get(0);
        int count = rowCount.intValue();
        // return ( Long ) criteria.uniqueResult( );
        return count;
    } finally {
        session.close();
    }
}

From source file:abid.password.wicket.dao.AbstractHibernateDao.java

License:Apache License

@Transactional(type = TransactionType.READ_ONLY)
@SuppressWarnings("rawtypes")
public int countAll() {
    Criteria criteria = session.get().createCriteria(persistentClass);
    criteria.setProjection(Projections.rowCount());

    List result = criteria.list();
    Long rowCount = (Long) result.get(0);
    int count = rowCount.intValue();
    // return ( Long ) criteria.uniqueResult( );
    return count;

}

From source file:analysers.MarketValueAnalyser.java

License:Open Source License

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

    HibernateSupport.beginTransaction();
    Criteria cr = HibernateSupport.getCurrentSession().createCriteria(News.class);
    cr.createAlias("news_details", "details");
    cr.add(Restrictions.ge("details.total_objectivity", 0.5));
    cr.add(Restrictions.le("details.total_objectivity", 1.0));
    cr.setProjection(Projections.rowCount());
    long size = (long) cr.uniqueResult();
    HibernateSupport.commitTransaction();

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

    MarketValueAnalyser mva = new MarketValueAnalyser();
    //mva.createDistributionTable(40, 1, MarketValueAnalyser.Analyse.AFTER, false);
    mva.createDistributionTable(40, 3, MarketValueAnalyser.Analyse.AFTER, false);
    mva.createDistributionTable(40, 5, MarketValueAnalyser.Analyse.AFTER, false);
    mva.createDistributionTable(40, 7, MarketValueAnalyser.Analyse.AFTER, false);

    mva.createDistributionTable(40, 1, MarketValueAnalyser.Analyse.BEFORE, false);
    mva.createDistributionTable(40, 3, MarketValueAnalyser.Analyse.BEFORE, false);
    mva.createDistributionTable(40, 5, MarketValueAnalyser.Analyse.BEFORE, false);
    mva.createDistributionTable(40, 7, MarketValueAnalyser.Analyse.BEFORE, false);

}

From source file:analysers.TextAnalyserManager.java

License:Open Source License

/**
 * The main method.//from   w  w w.  ja va 2 s.com
 *
 * @param argv the arguments
 * @throws SecurityException the security exception
 * @throws IOException Signals that an I/O exception has occurred.
 */
public static void main(String[] argv) throws SecurityException, IOException {
    TextAnalyserManager tam = new TextAnalyserManager();

    Logger logger = Logger.getLogger("MyLogger");
    logger.setUseParentHandlers(false);
    String date = new SimpleDateFormat("dd-MM-yyyy").format(new Date());
    FileHandler fh = new FileHandler("data/tmp/addsentencesentiment-" + date + ".log", true);
    logger.addHandler(fh);

    List<News> company_news = new ArrayList<News>();
    News single_company_news;
    HibernateSupport.beginTransaction();
    long news_size = (long) HibernateSupport.getCurrentSession().createCriteria(News.class)
            .setProjection(Projections.rowCount()).uniqueResult();
    HibernateSupport.commitTransaction();
    System.out.println(news_size);

    int counter = 94500;
    int increment_by = 500;
    for (int offset = counter; offset < news_size; offset += increment_by) {
        company_news.clear();
        System.gc();
        company_news = HibernateSupport.readMoreObjects(News.class, new ArrayList<Criterion>(), offset,
                increment_by);
        System.out.println(offset + " news, of " + news_size + " edited.");

        //HibernateSupport.beginTransaction();

        while (company_news.size() > 0) {
            single_company_news = company_news.get(0);
            company_news.remove(0);
            if (!tam.sensium_analyser.getEntitiesAndMapNewsNew(single_company_news)) {
                logger.info("language: " + single_company_news.getLanguage() + " news-hash: "
                        + single_company_news.getHash());
            }
            System.out.println(++counter + "/" + news_size);
        }
        //HibernateSupport.commitTransaction();

    }

    return;
    /*try {
       tam.execute(null);
    } catch (JobExecutionException e) {
       e.printStackTrace();
    }*/

}

From source file:apm.common.core.DaoImpl.java

License:Open Source License

/**
 * //w w  w.j a v  a  2  s .c  om
 * @param detachedCriteria
 * @return
 */
@SuppressWarnings("rawtypes")
public long count(DetachedCriteria detachedCriteria) {
    Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
    long totalCount = 0;
    try {
        // Get orders
        Field field = CriteriaImpl.class.getDeclaredField("orderEntries");
        field.setAccessible(true);
        List orderEntrys = (List) field.get(criteria);
        // Remove orders
        field.set(criteria, new ArrayList());
        // Get count
        criteria.setProjection(Projections.rowCount());
        totalCount = Long.valueOf(criteria.uniqueResult().toString());
        // Clean count
        criteria.setProjection(null);
        // Restore orders
        field.set(criteria, orderEntrys);
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return totalCount;
}

From source file:ar.com.zauber.commons.repository.aggregate.ProjectionAggregateFunctionVisitor.java

License:Apache License

/** crea projecciones en base a {@link ParameterlessAggregateFunction}. */
private static Projection createParameterlessProjection(final ParameterlessAggregateFunction paf) {
    final Projection projection;
    if (paf instanceof RowCountAggregateFilter) {
        projection = Projections.rowCount();
    } else {/* w  w  w .  ja v a  2  s .c  o m*/
        throw new IllegalArgumentException("don't know how to process " + paf.getClass());
    }

    return projection;
}

From source file:au.edu.archer.dimsim.buffer.pool.impl.HibernateBuffer.java

License:Open Source License

public int getSize() {

    if (this.sessionFactory == null)
        return -1;

    Criteria criteria = this.sessionFactory.getCurrentSession().createCriteria(DimsimORMStore.class);
    criteria.setProjection(Projections.rowCount());

    return ((Integer) criteria.list().get(0)).intValue();
}

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

License:Open Source License

/**
 * Loads all the bookings for the day into memory.
 * //w  w w  . j a v a  2 s.c om
 * @return ses database session
 */
@SuppressWarnings("unchecked")
public void fullLoad(Session ses) {
    if (this.hasFullLoad)
        return;

    int num = 0;

    /* Load all the rigs that have bookings today. */
    for (Rig rig : (List<Rig>) ses.createCriteria(Rig.class).list()) {
        if (this.rigBookings.containsKey(rig.getName()))
            continue;

        if ((num = (Integer) ses.createCriteria(Bookings.class).add(Restrictions.eq("active", Boolean.TRUE))
                .add(this.addDayRange()).add(Restrictions.eq("resourceType", ResourcePermission.RIG_PERMISSION))
                .add(Restrictions.eq("rig", rig)).setProjection(Projections.rowCount()).uniqueResult()) == 0)
            continue;

        this.logger.debug(
                "Rig " + rig.getName() + " has " + num + " bookings, so loading it up for full day load.");
        this.getRigBookings(rig, ses);
    }

    /* Load all the rig types that have bookings today. */
    Criteria qu = ses.createCriteria(RigType.class);
    if (this.typeTargets.size() > 0)
        qu.add(Restrictions.not(Restrictions.in("name", this.typeTargets.keySet())));
    for (RigType type : (List<RigType>) qu.list()) {
        if (this.typeTargets.containsKey(type.getName()))
            continue;

        if ((num = (Integer) ses.createCriteria(Bookings.class).add(Restrictions.eq("active", Boolean.TRUE))
                .add(this.addDayRange())
                .add(Restrictions.eq("resourceType", ResourcePermission.TYPE_PERMISSION))
                .add(Restrictions.eq("rigType", type)).setProjection(Projections.rowCount())
                .uniqueResult()) == 0)
            continue;

        this.logger.debug("Rig type " + type.getName() + " has " + num + " bookings, so loading it up for"
                + " full day load.");

        Set<Rig> rigs = type.getRigs();
        if (rigs.size() == 0) {
            this.logger.warn("Rig type " + type.getName() + " has " + num + " bookings but not rigs so they all"
                    + " will be cancelled.");
            for (Bookings bk : (List<Bookings>) ses.createCriteria(Bookings.class)
                    .add(Restrictions.eq("active", Boolean.TRUE)).add(this.addDayRange())
                    .add(Restrictions.eq("resourceType", ResourcePermission.TYPE_PERMISSION))
                    .add(Restrictions.eq("rigType", type)).list()) {
                this.logger.warn("Cancelling booking for " + bk.getUser().qName() + " because booking rig type "
                        + type.getName() + " has no rigs.");
                bk.setActive(false);
                bk.setCancelReason("Booked rig type has no rigs.");

                new BookingNotification(bk).notifyCancel();
            }
            ses.beginTransaction();
            ses.flush();
            ses.getTransaction().commit();
            continue;
        }

        this.getRigBookings(rigs.iterator().next(), ses);
    }

    /* Load all the request capabilities that have bookings today. */
    qu = ses.createCriteria(RequestCapabilities.class);
    if (this.capsTargets.size() > 0)
        qu.add(Restrictions.not(Restrictions.in("capabilities", this.capsTargets.keySet())));
    for (RequestCapabilities caps : (List<RequestCapabilities>) qu.list()) {
        if (this.capsTargets.containsKey(caps.getCapabilities()))
            continue;

        if ((num = (Integer) ses.createCriteria(Bookings.class).add(Restrictions.eq("active", Boolean.TRUE))
                .add(this.addDayRange())
                .add(Restrictions.eq("resourceType", ResourcePermission.CAPS_PERMISSION))
                .add(Restrictions.eq("requestCapabilities", caps)).setProjection(Projections.rowCount())
                .uniqueResult()) == 0)
            continue;

        this.logger.debug("Request capabilities " + caps.getCapabilities() + " has " + num + " bookings, so "
                + "loading it up for full day load.");

        List<RequestCapabilities> capsList = new ArrayList<RequestCapabilities>();
        capsList.add(caps);
        this.loadRequestCapabilities(capsList, ses, true);

        if (!this.capsTargets.containsKey(caps.getCapabilities())) {
            this.logger.warn("Request capabilities " + caps.getCapabilities() + " has " + num + " bookings but "
                    + "not any matching rigs so they all will be cancelled.");
            for (Bookings bk : (List<Bookings>) ses.createCriteria(Bookings.class)
                    .add(Restrictions.eq("active", Boolean.TRUE)).add(this.addDayRange())
                    .add(Restrictions.eq("resourceType", ResourcePermission.CAPS_PERMISSION))
                    .add(Restrictions.eq("requestCapabilities", caps)).list()) {
                this.logger.warn("Cancelling booking for " + bk.getUser().qName() + " because booking request "
                        + "capabilities " + caps.getCapabilities() + " has no matching rigs.");
                bk.setActive(false);
                bk.setCancelReason("Booked request capabilities has no rigs.");

                new BookingNotification(bk).notifyCancel();
            }
            ses.beginTransaction();
            ses.flush();
            ses.getTransaction().commit();
        }
    }
}

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);//from  ww  w . j  a v  a  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   www.  ja  v a  2 s .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;
}