Example usage for org.hibernate.criterion Restrictions in

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

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

Introduction

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

Prototype

public static Criterion in(String propertyName, Collection values)

Source Link

Document

Apply an "in" constraint to the named property.

Usage

From source file:search_prop.java

/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods./* w w  w  .  j a  v a 2  s  . c  om*/
 *
 * @param request servlet request
 * @param response servlet response
 * @throws ServletException if a servlet-specific error occurs
 * @throws IOException if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
    try {
        SessionFactory sf = NewHibernateUtil.getSessionFactory();
        Session ss = sf.openSession();
        String[] bhkGroup = request.getParameterValues("bhkgroup");
        String[] typeGroup = request.getParameterValues("typegroup");

        System.out.println("the types are:" + typeGroup[0]);
        System.out.println("the bhks are:" + bhkGroup[0]);

        String stateid = request.getParameter("state");
        String cityid = request.getParameter("city");
        String areaid = request.getParameter("area");
        //            String minp = request.getParameter("minprice");
        //            String maxp = request.getParameter("maxprice");
        //            String minsq = request.getParameter("minsqfeet");
        //            String maxsq = request.getParameter("maxsqfeet");
        //            

        //Edited
        int minp = Integer.parseInt(request.getParameter("minprice"));
        int maxp = Integer.parseInt(request.getParameter("maxprice"));
        int minsq = Integer.parseInt(request.getParameter("minsqfeet"));
        int maxsq = Integer.parseInt(request.getParameter("maxsqfeet"));

        String state = "";
        Criteria cr1 = ss.createCriteria(StateMaster.class);
        cr1.add(Restrictions.eq("sId", Integer.parseInt(stateid)));
        ArrayList<StateMaster> ar = (ArrayList<StateMaster>) cr1.list();
        System.out.println("----------" + ar.size());
        if (ar.isEmpty()) {

        } else {
            state = ar.get(0).getSName();
            System.out.println("-------" + state);
        }

        String city = "";
        Criteria cr2 = ss.createCriteria(CityMaster.class);
        cr2.add(Restrictions.eq("cityId", Integer.parseInt(cityid)));
        ArrayList<CityMaster> ar2 = (ArrayList<CityMaster>) cr2.list();
        System.out.println("----------" + ar2.size());
        if (ar2.isEmpty()) {

        } else {
            city = ar2.get(0).getCityName();
            System.out.println("-------" + city);
        }

        String area = "";
        Criteria cr3 = ss.createCriteria(AreaMaster.class);
        cr3.add(Restrictions.eq("areaId", Integer.parseInt(areaid)));
        ArrayList<AreaMaster> ar3 = (ArrayList<AreaMaster>) cr3.list();
        System.out.println("----------" + ar3.size());
        if (ar3.isEmpty()) {

        } else {
            area = ar3.get(0).getAreaName();
            System.out.println("-------" + area);
        }

        System.out.println(minp + " " + maxp + " " + minsq + " " + maxsq);

        Criteria cr = ss.createCriteria(PropDetail.class);
        cr.add(Restrictions.in("pBhk", bhkGroup));
        cr.add(Restrictions.in("pType", typeGroup));
        cr.add(Restrictions.eq("pState", state));
        cr.add(Restrictions.eq("pCity", city));
        cr.add(Restrictions.eq("pArea", area));
        cr.add(Restrictions.between("pPrice", minp, maxp));
        cr.add(Restrictions.between("pFloor", minsq, maxsq));

        ArrayList<PropDetail> pd = (ArrayList<PropDetail>) cr.list();

        /*   for(PropDetail p: pd)
         {
         out.print(p.getPId()+" type:"+p.getPType()+" bhk:"+p.getPBhk());
         out.println(" ");
         }
         */
        if (pd.isEmpty()) {
            out.print("no such property");
            String msg = "Sorry, No results found.";
            request.setAttribute("error", msg);
        } else {
            request.setAttribute("proplist", pd);
        }
        RequestDispatcher rd = request.getRequestDispatcher("getstate?id=9");
        rd.forward(request, response);

    } catch (HibernateException e) {
        out.println("There was some error with the taken action.");
        System.out.print(e.getMessage());
    }
}

From source file:alpha.portal.service.impl.AlphaCardManagerImpl.java

License:Apache License

/**
 * Returns a {@link Criterion} to get all Adornments where the
 * contributorrole is one of roles.//w w  w .  j  a v  a 2 s .  c  om
 * 
 * @param roles
 *            the roles
 * @return a {@link Criterion}
 */
public static Criterion getContributorRoleCriterionOwn(final String... roles) {
    return Restrictions.and(AlphaCardManagerImpl._CONTRIBUTORROLE, Restrictions.in("ad.value", roles));
}

From source file:alpha.portal.service.impl.AlphaCardManagerImpl.java

License:Apache License

/**
 * Returns a {@link Criterion} to get all Adornments where the
 * contributorrole is not in roles.//from  w w w.  ja  v a  2 s .c  o m
 * 
 * @param roles
 *            the roles
 * @return a {@link Criterion}
 */
public static Criterion getContributorRoleCriterionOthers(final String... roles) {
    return Restrictions.and(AlphaCardManagerImpl._CONTRIBUTORROLE,
            Restrictions.not(Restrictions.in("ad.value", roles)));
}

From source file:alpha.portal.service.impl.AlphaCardManagerImplTest.java

License:Apache License

/**
 * Test criterion.//from  w  ww .j  a  v a2s.c  o  m
 */
@Test
public void testCriterion() {
    Assert.assertEquals(
            Restrictions.and(AlphaCardManagerImpl._CONTRIBUTOR, Restrictions.ne("ad.value", "123")).toString(),
            AlphaCardManagerImpl.getContributorCriterionOthers("123").toString());
    Assert.assertEquals(
            Restrictions.and(AlphaCardManagerImpl._CONTRIBUTOR, Restrictions.eq("ad.value", "123")).toString(),
            AlphaCardManagerImpl.getContributorCriterionOwn("123").toString());
    Assert.assertEquals(
            Restrictions.and(AlphaCardManagerImpl._CONTRIBUTORROLE,
                    Restrictions.not(Restrictions.in("ad.value", new String[] { "role1" }))).toString(),
            AlphaCardManagerImpl.getContributorRoleCriterionOthers("role1").toString());
    Assert.assertEquals(
            Restrictions.and(AlphaCardManagerImpl._CONTRIBUTORROLE,
                    Restrictions.in("ad.value", new String[] { "role1" })).toString(),
            AlphaCardManagerImpl.getContributorRoleCriterionOwn("role1").toString());
}

From source file:apm.common.service.DataService.java

License:Open Source License

/**
 * ?//from  ww w. ja  v  a2s  . co m
 * @param dc Hibernate
 * @param user ?UserUtils.getUser()??
 * @param officeAlias ??dc.createAlias("office", "office");
 * @param userAlias ???
 * @return ?
 */
protected static Junction dataScopeFilter(User user, String officeAlias, String userAlias) {

    // ????
    List<String> dataScope = Lists.newArrayList();
    Junction junction = Restrictions.disjunction();

    // ???
    if (!user.isAdmin()) {
        for (Role r : user.getRoleList()) {
            String DATA_SCOPE = r.getDataScope();
            if (!dataScope.contains(DATA_SCOPE) && StringUtils.isNotBlank(officeAlias)) {
                boolean isDataScopeAll = false;
                if (Role.DATA_SCOPE_ALL.equals(DATA_SCOPE)) {
                    isDataScopeAll = true;
                } else if (Role.DATA_SCOPE_COMPANY_AND_CHILD.equals(DATA_SCOPE)) { //(?)??
                    junction.add(Restrictions.eq(officeAlias + ".id", user.getCompany().getId()));
                    junction.add(Restrictions.like(officeAlias + ".parentIds",
                            user.getCompany().getParentIds() + user.getCompany().getId() + ",%"));
                } else if (Role.DATA_SCOPE_COMPANY.equals(DATA_SCOPE)) {
                    junction.add(Restrictions.eq(officeAlias + ".id", user.getCompany().getId()));
                    junction.add(Restrictions.and(
                            Restrictions.eq(officeAlias + ".parent.id", user.getCompany().getId()),
                            Restrictions.eq(officeAlias + ".type", "2"))); // ?
                } else if (Role.DATA_SCOPE_OFFICE_AND_CHILD.equals(DATA_SCOPE)) {
                    junction.add(Restrictions.eq(officeAlias + ".id", user.getOffice().getId()));
                    junction.add(Restrictions.like(officeAlias + ".parentIds",
                            user.getOffice().getParentIds() + user.getOffice().getId() + ",%"));
                } else if (Role.DATA_SCOPE_OFFICE.equals(DATA_SCOPE)) {
                    junction.add(Restrictions.eq(officeAlias + ".id", user.getOffice().getId()));
                } else if (Role.DATA_SCOPE_CUSTOM.equals(DATA_SCOPE)) {
                    junction.add(Restrictions.in(officeAlias + ".id", r.getOfficeIdList()));
                }
                //else if (Role.DATA_SCOPE_SELF.equals(DATA_SCOPE)){
                if (!isDataScopeAll) {
                    if (StringUtils.isNotBlank(userAlias)) {
                        junction.add(Restrictions.eq(userAlias + ".id", user.getId()));
                    } else {
                        junction.add(Restrictions.isNull(officeAlias + ".id"));
                    }
                } else {
                    // ?????
                    junction = Restrictions.disjunction();
                    break;
                }
                dataScope.add(DATA_SCOPE);
            }
        }
    }
    return junction;
}

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

License:Apache License

/** @see FilterVisitor#visitInPropertyFilter(InPropertyFilter) */
public final void visitInPropertyFilter(final InPropertyFilter inPropertyFilter) {
    String fieldName = getFieldName(inPropertyFilter.getProperty());
    criterion = Restrictions.in(fieldName, CollectionUtils
            .collect(inPropertyFilter.getValues(), new BeanToPropertyValueTransformer("value")).toArray());
    negateIfNeeded(inPropertyFilter);/*from   ww w  .java 2s  .  c  o  m*/
}

From source file:ar.com.zauber.commons.repository.SpringHibernateRepository.java

License:Apache License

/** @see Repository#find(Query) */
@SuppressWarnings("unchecked")
public final <T extends Persistible> List<T> find(final Query<T> query) {
    CriteriaSpecification criteria = getCriteriaSpecification(null, query, false);
    final SimpleQuery<T> simpleQuery = (SimpleQuery<T>) query;
    Criteria aCriteria;//from   w w  w  . j a  v  a  2  s . c  om
    // TODO Esto debera ir en el metodo que hace getCriteriaSpecification
    // pero como no tiene DetachedCriteria posibilidad de setearle valores
    // para paginacin hubo que hacerlo as.
    if (simpleQuery.getPaging() != null) {
        int firstResult = (simpleQuery.getPaging().getPageNumber() - 1)
                * simpleQuery.getPaging().getResultsPerPage();
        DetachedCriteria idsDetachedCriteria = (DetachedCriteria) criteria;
        idsDetachedCriteria.setProjection(Projections.id());
        Criteria idsCriteria = idsDetachedCriteria.getExecutableCriteria(this.getSession());
        idsCriteria.setCacheable(query.getCacheable());
        idsCriteria.setFirstResult(firstResult);
        idsCriteria.setMaxResults(simpleQuery.getPaging().getResultsPerPage());
        // Se hace primero el select de los IDs y luego el de los objetos en
        // si ya que de otra manera en aquellos casos que haya objetos
        // que tienen colecciones cuenta los mismos varias veces haciendo
        // que se devuelvan menos resultados.
        List<Long> ids = idsCriteria.list();
        DetachedCriteria theCriteria = (DetachedCriteria) getCriteriaSpecification(null, query, false);
        if (ids.isEmpty()) {
            return new ArrayList<T>();
        }
        theCriteria.add(Restrictions.in("id", ids));
        aCriteria = theCriteria.getExecutableCriteria(this.getSession());

    } else {
        aCriteria = ((DetachedCriteria) criteria).getExecutableCriteria(this.getSession());
    }
    aCriteria.setCacheable(query.getCacheable());
    return aCriteria.list();
}

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.
 * //from  w w w  .j a va2  s.  co m
 * @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 FindFreeBookingsResponse findFreeBookings(FindFreeBookings findFreeBookings) {
    /* --------------------------------------------------------------------
     * -- Read request parameters.                                       --
     * -------------------------------------------------------------------- */
    FindBookingSlotType request = findFreeBookings.getFindBookingSlots();
    String debug = "Received " + this.getClass().getSimpleName() + "#findFreeBookings with params: ";

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

    PermissionIDType reqPermission = request.getPermissionID();
    if (reqPermission != null)
        debug += " permission ID=" + reqPermission.getPermissionID();

    ResourceIDType reqResource = request.getResourceID();
    if (reqResource != null)
        debug += " resource type= " + reqResource.getType() + ", ID=" + request.getResourceID().getResourceID()
                + ", name=" + reqResource.getResourceName();

    Calendar reqStart = request.getPeriod().getStartTime();
    Calendar reqEnd = request.getPeriod().getEndTime();
    this.dstHack(reqStart);
    this.dstHack(reqEnd);

    debug += " period start=" + reqStart.getTime() + ", period end=" + reqEnd.getTime();
    this.logger.debug(debug);

    /* --------------------------------------------------------------------
     * -- Generate valid, blank request parameters.                      --
     * -------------------------------------------------------------------- */
    FindFreeBookingsResponse response = new FindFreeBookingsResponse();
    BookingSlotListType slots = new BookingSlotListType();
    response.setFindFreeBookingsResponse(slots);

    PermissionIDType permission = new PermissionIDType();
    slots.setPermissionID(permission);/*  w w w  . java 2s  .c o m*/

    ResourceIDType resource = new ResourceIDType();
    resource.setType("TYPE");
    slots.setResourceID(resource);

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

        /* ----------------------------------------------------------------
         * -- Load the permission.                                             --
         * ---------------------------------------------------------------- */
        ResourcePermission perm = null;
        if (reqPermission != null) {
            ResourcePermissionDao resPermissionDao = new ResourcePermissionDao(ses);
            perm = resPermissionDao.get(Long.valueOf(reqPermission.getPermissionID()));
        } else if (reqResource != null) {
            Criteria qu = ses.createCriteria(ResourcePermission.class);

            /* Add resource restrictions. */
            qu.add(Restrictions.eq("type", reqResource.getType()));
            if (ResourcePermission.TYPE_PERMISSION.equals(reqResource.getType())) {
                if (reqResource.getResourceID() > 0) {
                    qu.add(Restrictions.eq("rigType.id", Long.valueOf(reqResource.getResourceID())));
                }
                if (reqResource.getResourceName() != null) {
                    qu.createCriteria("rigType").add(Restrictions.eq("name", reqResource.getResourceName()));
                }
            } else if (ResourcePermission.RIG_PERMISSION.equals(reqResource.getType())) {
                if (reqResource.getResourceID() > 0) {
                    qu.add(Restrictions.eq("rig.id", Long.valueOf(reqResource.getResourceID())));
                }
                if (reqResource.getResourceName() != null) {
                    qu.createCriteria("rig").add(Restrictions.eq("name", reqResource.getResourceName()));
                }
            } else if (ResourcePermission.CAPS_PERMISSION.equals(reqResource.getType())) {
                if (reqResource.getResourceID() > 0) {
                    qu.add(Restrictions.eq("requestCapabilities.id",
                            Long.valueOf(reqResource.getResourceID())));
                }
                if (reqResource.getResourceName() != null) {
                    qu.createCriteria("requestCapabilities")
                            .add(Restrictions.eq("capabilities", reqResource.getResourceName()));
                }
            } else {
                this.logger.warn("Unable to provide free times because resource type " + reqResource.getType()
                        + " is not understood.");
                return response;
            }

            List<UserClass> uc = new ArrayList<UserClass>();
            for (UserAssociation assoc : user.getUserAssociations())
                uc.add(assoc.getUserClass());

            /* The permission user class must be active and bookable. */
            qu.createCriteria("userClass").add(Restrictions.eq("active", Boolean.TRUE))
                    .add(Restrictions.eq("bookable", Boolean.TRUE));
            qu.add(Restrictions.in("userClass", uc));

            /* Add order in case we need to count in range, latest first. */
            qu.addOrder(Order.desc("startTime"));

            @SuppressWarnings("unchecked")
            List<ResourcePermission> rpList = qu.list();
            if (rpList.size() == 1) {
                /* One permission so good to go. */
                perm = rpList.get(0);
            } else if (rpList.size() > 1) {
                Date rsd = reqStart.getTime();
                Date red = reqEnd.getTime();
                /* Multiple permissions so we take the permission in time range. */
                for (ResourcePermission rp : rpList) {
                    if (rp.getStartTime().before(rsd) && rp.getExpiryTime().after(rsd)
                            || rp.getStartTime().before(red) && rp.getExpiryTime().after(red)
                            || rp.getStartTime().after(rsd) && rp.getExpiryTime().before(red)) {
                        perm = rp;
                        break;
                    }
                }

                /* Nothing in range so it doesn't matter which resource we give. */
                if (perm == null)
                    perm = rpList.get(0);
            }
        }

        /* If no permission is specified, either it doesn't exist or it wasn't
         * specified. Either way, we can't provide any information. */
        if (perm == null) {
            this.logger
                    .warn("Unable to provide free times because no permission or resource has been specified "
                            + "or found to provide the free times of.");
            return response;
        }

        /* Make sure the permission a valid booking permission. */
        if (!(perm.getUserClass().isActive() && perm.getUserClass().isBookable())) {
            this.logger.warn(
                    "Unable to provide free times because the permission is not a valid booking permission.");
            return response;
        }

        /* There is a permission, but the user doesn't have it. */
        if (!this.checkPermission(user, perm)) {
            this.logger.warn("Unable to provide free times to user " + user.getNamespace() + ':'
                    + user.getName() + " because they do not have permission " + perm.getId() + ".");
            return response;
        }

        /* ----------------------------------------------------------------
         * -- Populate the response with permission parameters.          --
         * ---------------------------------------------------------------- */
        permission.setPermissionID(perm.getId().intValue());
        resource.setType(perm.getType());
        if (ResourcePermission.RIG_PERMISSION.equals(perm.getType())) {
            Rig rig = perm.getRig();
            if (rig == null) {
                this.logger.warn("Unable to provide free times because the rig permission with ID="
                        + perm.getId() + " is not set with a rig.");
                return response;
            }
            resource.setResourceID(rig.getId().intValue());
            resource.setResourceName(rig.getName());
        } else if (ResourcePermission.TYPE_PERMISSION.equals(perm.getType())) {
            RigType rigType = perm.getRigType();
            if (rigType == null) {
                this.logger.warn("Unable to provide free times because the rig type permission with ID="
                        + perm.getId() + " is not set with a rig type.");
                return response;
            }
            resource.setResourceID(rigType.getId().intValue());
            resource.setResourceName(rigType.getName());
        } else if (ResourcePermission.CAPS_PERMISSION.equals(perm.getType())) {
            RequestCapabilities caps = perm.getRequestCapabilities();
            if (caps == null) {
                this.logger.warn(
                        "Unable to provide free times because the request capabilities permission with ID="
                                + perm.getId() + " is not set with a request capabilities.");
                return response;
            }
            resource.setResourceID(caps.getId().intValue());
            resource.setResourceName(caps.getCapabilities());
        } else {
            this.logger.warn("Unable to provide free times because the permission with ID=" + perm.getId()
                    + " has type '" + perm.getType() + "' which is not understood.");
            return response;
        }

        /* ----------------------------------------------------------------
         * -- Check permission times to make sure the request is within  --
         * -- the permission start and expiry range.                     --
         * ---------------------------------------------------------------- */
        Calendar permStart = Calendar.getInstance();
        permStart.setTime(perm.getStartTime());

        /* The /actual/ permission start time may either be the permission 
         * start time or the time horizon time. This is a second offset from
         * the current time (i.e. it atleast stops bookings being made for
         * the past. */
        Calendar horizonTime = Calendar.getInstance();
        horizonTime.add(Calendar.SECOND, perm.getUserClass().getTimeHorizon());
        if (horizonTime.after(permStart)) {
            /* Which ever comes later. */
            permStart = TimeUtil.coerceToNextSlotTime(horizonTime);
        }

        Calendar permEnd = Calendar.getInstance();
        permEnd.setTime(perm.getExpiryTime());

        if (reqEnd.before(permStart) || reqStart.after(permEnd) || permEnd.before(permStart)) {
            /* In this case the requested range is, after the end of the 
             * permission region, before the start of the permission 
             * region or the permission start is after the permission end
             * (the permission start is always sliding for horizion). */
            BookingSlotType slot = new BookingSlotType();
            slot.setSlot(request.getPeriod());
            slot.setState(SlotState.NOPERMISSION);
            slots.addBookingSlot(slot);

            return response;
        }

        if (reqStart.before(permStart)) {
            /* Here the permission start time is after the requested start time 
             * so the start partial date has no permission. */
            TimePeriodType tp = new TimePeriodType();
            tp.setStartTime(reqStart);
            tp.setEndTime(permStart);
            BookingSlotType slot = new BookingSlotType();
            slot.setSlot(tp);
            slot.setState(SlotState.NOPERMISSION);
            slots.addBookingSlot(slot);

            /* The permission start time is now the search start time. */
            reqStart = permStart;
        }

        Calendar searchEnd = reqEnd;
        if (reqEnd.after(permEnd)) {
            /* Here the permission end time is before the requested end time
             * so the end partial date has no permission. We will search the free
             * search end to the permission end but add the no permission period
             * last. */
            searchEnd = permEnd;
        }

        /* ----------------------------------------------------------------
         * -- Get the free times for the permission resource.            --
         * ---------------------------------------------------------------- */
        List<TimePeriod> free = null;
        resource.setType(perm.getType());
        if (ResourcePermission.RIG_PERMISSION.equals(perm.getType())) {
            free = this.engine.getFreeTimes(perm.getRig(), new TimePeriod(reqStart, searchEnd),
                    perm.getSessionDuration() / 2, ses);
        } else if (ResourcePermission.TYPE_PERMISSION.equals(perm.getType())) {
            free = this.engine.getFreeTimes(perm.getRigType(), new TimePeriod(reqStart, searchEnd),
                    perm.getSessionDuration() / 2, ses);
        } else if (ResourcePermission.CAPS_PERMISSION.equals(perm.getType())) {
            free = this.engine.getFreeTimes(perm.getRequestCapabilities(), new TimePeriod(reqStart, searchEnd),
                    perm.getSessionDuration() / 2, ses);
        }

        /* ----------------------------------------------------------------
         * -- Populate the resource with free and booked time            --
         * ---------------------------------------------------------------- */
        Calendar c = reqStart;

        if (free.size() > 0) {
            for (TimePeriod period : free) {
                if (Math.abs(period.getStartTime().getTimeInMillis() - c.getTimeInMillis()) > 60000) {
                    /* The difference with the last time and the next time is
                     * more than a minute, then there should be a booked period. */
                    TimePeriodType tp = new TimePeriodType();
                    tp.setStartTime(c);
                    tp.setEndTime(period.getStartTime());
                    BookingSlotType slot = new BookingSlotType();
                    slot.setSlot(tp);
                    slot.setState(SlotState.BOOKED);
                    slots.addBookingSlot(slot);
                }

                TimePeriodType tp = new TimePeriodType();
                tp.setStartTime(period.getStartTime());
                tp.setEndTime(period.getEndTime());
                BookingSlotType slot = new BookingSlotType();
                slot.setSlot(tp);
                slot.setState(SlotState.FREE);
                slots.addBookingSlot(slot);

                c = period.getEndTime();
            }

            /* There is a booked spot at the end. */
            if (Math.abs(searchEnd.getTimeInMillis() - c.getTimeInMillis()) > 60000) {
                /* The difference with the last time and the next time is
                 * more than a minute, then there should be a booked period. */
                TimePeriodType tp = new TimePeriodType();
                tp.setStartTime(c);
                tp.setEndTime(searchEnd);
                BookingSlotType slot = new BookingSlotType();
                slot.setSlot(tp);
                slot.setState(SlotState.BOOKED);
                slots.addBookingSlot(slot);
            }
        } else {
            /* There is no free times on the day. */
            TimePeriodType tp = new TimePeriodType();
            tp.setStartTime(reqStart);
            tp.setEndTime(reqEnd);
            BookingSlotType slot = new BookingSlotType();
            slot.setSlot(tp);
            slot.setState(SlotState.BOOKED);
            slots.addBookingSlot(slot);
        }

        if (reqEnd.after(permEnd)) {
            /* Add a no permission at the end. */
            TimePeriodType tp = new TimePeriodType();
            tp.setStartTime(permEnd);
            tp.setEndTime(reqEnd);
            BookingSlotType slot = new BookingSlotType();
            slot.setSlot(tp);
            slot.setState(SlotState.NOPERMISSION);
            slots.addBookingSlot(slot);
        }
    } finally {
        ses.close();
    }

    return response;
}

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

License:Open Source License

@Override
public FindFreeBookingsResponse findFreeBookings(FindFreeBookings findFreeBookings) {
    /* --------------------------------------------------------------------
     * -- Read request parameters.                                       --
     * -------------------------------------------------------------------- */
    FindBookingSlotType request = findFreeBookings.getFindBookingSlots();
    String debug = "Received " + this.getClass().getSimpleName() + "#findFreeBookings with params: ";

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

    PermissionIDType reqPermission = request.getPermissionID();
    if (reqPermission != null)
        debug += " permission ID=" + reqPermission.getPermissionID();

    ResourceIDType reqResource = request.getResourceID();
    if (reqResource != null)
        debug += " resource type= " + reqResource.getType() + ", ID=" + request.getResourceID().getResourceID()
                + ", name=" + reqResource.getResourceName();

    Calendar reqStart = request.getPeriod().getStartTime();
    Calendar reqEnd = request.getPeriod().getEndTime();
    this.dstHack(reqStart);
    this.dstHack(reqEnd);

    debug += " period start=" + reqStart.getTime() + ", period end=" + reqEnd.getTime();
    this.logger.debug(debug);

    /* --------------------------------------------------------------------
     * -- Generate valid, blank request parameters.                      --
     * -------------------------------------------------------------------- */
    FindFreeBookingsResponse response = new FindFreeBookingsResponse();
    BookingSlotListType slots = new BookingSlotListType();
    response.setFindFreeBookingsResponse(slots);

    PermissionIDType permission = new PermissionIDType();
    slots.setPermissionID(permission);//w  w w.  j a va2s. com

    ResourceIDType resource = new ResourceIDType();
    resource.setType("TYPE");
    slots.setResourceID(resource);

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

        /* ----------------------------------------------------------------
         * -- Load the permission.                                             --
         * ---------------------------------------------------------------- */
        ResourcePermission perm = null;
        if (reqPermission != null) {
            ResourcePermissionDao resPermissionDao = new ResourcePermissionDao(db);
            perm = resPermissionDao.get(Long.valueOf(reqPermission.getPermissionID()));
        } else if (reqResource != null) {
            Criteria qu = db.createCriteria(ResourcePermission.class);

            /* Add resource restrictions. */
            qu.add(Restrictions.eq("type", reqResource.getType()));
            if (ResourcePermission.TYPE_PERMISSION.equals(reqResource.getType())) {
                if (reqResource.getResourceID() > 0) {
                    qu.add(Restrictions.eq("rigType.id", Long.valueOf(reqResource.getResourceID())));
                }
                if (reqResource.getResourceName() != null) {
                    qu.createCriteria("rigType").add(Restrictions.eq("name", reqResource.getResourceName()));
                }
            } else if (ResourcePermission.RIG_PERMISSION.equals(reqResource.getType())) {
                if (reqResource.getResourceID() > 0) {
                    qu.add(Restrictions.eq("rig.id", Long.valueOf(reqResource.getResourceID())));
                }
                if (reqResource.getResourceName() != null) {
                    qu.createCriteria("rig").add(Restrictions.eq("name", reqResource.getResourceName()));
                }
            } else if (ResourcePermission.CAPS_PERMISSION.equals(reqResource.getType())) {
                if (reqResource.getResourceID() > 0) {
                    qu.add(Restrictions.eq("requestCapabilities.id",
                            Long.valueOf(reqResource.getResourceID())));
                }
                if (reqResource.getResourceName() != null) {
                    qu.createCriteria("requestCapabilities")
                            .add(Restrictions.eq("capabilities", reqResource.getResourceName()));
                }
            } else {
                this.logger.warn("Unable to provide free times because resource type " + reqResource.getType()
                        + " is not understood.");
                return response;
            }

            List<UserClass> uc = new ArrayList<UserClass>();
            for (UserAssociation assoc : user.getUserAssociations())
                uc.add(assoc.getUserClass());

            /* The permission user class must be active and bookable. */
            qu.createCriteria("userClass").add(Restrictions.eq("active", Boolean.TRUE))
                    .add(Restrictions.eq("bookable", Boolean.TRUE));
            qu.add(Restrictions.in("userClass", uc));

            /* Add order in case we need to count in range, latest first. */
            qu.addOrder(Order.desc("startTime"));

            @SuppressWarnings("unchecked")
            List<ResourcePermission> rpList = qu.list();
            if (rpList.size() == 1) {
                /* One permission so good to go. */
                perm = rpList.get(0);
            } else if (rpList.size() > 1) {
                Date rsd = reqStart.getTime();
                Date red = reqEnd.getTime();
                /* Multiple permissions so we take the permission in time range. */
                for (ResourcePermission rp : rpList) {
                    if (rp.getStartTime().before(rsd) && rp.getExpiryTime().after(rsd)
                            || rp.getStartTime().before(red) && rp.getExpiryTime().after(red)
                            || rp.getStartTime().after(rsd) && rp.getExpiryTime().before(red)) {
                        perm = rp;
                        break;
                    }
                }

                /* Nothing in range so it doesn't matter which resource we give. */
                if (perm == null)
                    perm = rpList.get(0);
            }
        }

        /* If no permission is specified, either it doesn't exist or it wasn't
         * specified. Either way, we can't provide any information. */
        if (perm == null) {
            this.logger
                    .warn("Unable to provide free times because no permission or resource has been specified "
                            + "or found to provide the free times of.");
            return response;
        }

        /* There is a permission, but the user doesn't have it. */
        if (!this.checkPermission(user, perm)) {
            this.logger.warn("Unable to provide free times to user " + user.getNamespace() + ':'
                    + user.getName() + " because they do not have permission " + perm.getId() + ".");
            return response;
        }

        /* ----------------------------------------------------------------
         * -- Populate the response with permission parameters.          --
         * ---------------------------------------------------------------- */
        permission.setPermissionID(perm.getId().intValue());
        resource.setType(perm.getType());
        if (ResourcePermission.RIG_PERMISSION.equals(perm.getType())) {
            Rig rig = perm.getRig();
            if (rig == null) {
                this.logger.warn("Unable to provide free times because the rig permission with ID="
                        + perm.getId() + " is not set with a rig.");
                return response;
            }
            resource.setResourceID(rig.getId().intValue());
            resource.setResourceName(rig.getName());
        } else if (ResourcePermission.TYPE_PERMISSION.equals(perm.getType())) {
            RigType rigType = perm.getRigType();
            if (rigType == null) {
                this.logger.warn("Unable to provide free times because the rig type permission with ID="
                        + perm.getId() + " is not set with a rig type.");
                return response;
            }
            resource.setResourceID(rigType.getId().intValue());
            resource.setResourceName(rigType.getName());
        } else if (ResourcePermission.CAPS_PERMISSION.equals(perm.getType())) {
            RequestCapabilities caps = perm.getRequestCapabilities();
            if (caps == null) {
                this.logger.warn(
                        "Unable to provide free times because the request capabilities permission with ID="
                                + perm.getId() + " is not set with a request capabilities.");
                return response;
            }
            resource.setResourceID(caps.getId().intValue());
            resource.setResourceName(caps.getCapabilities());
        } else if (ResourcePermission.CONSUMER_PERMISSION.equalsIgnoreCase(perm.getType())) {
            resource.setResourceID(-1); // Faking ID.
            resource.setResourceName("Fake");
        } else {
            this.logger.warn("Unable to provide free times because the permission with ID=" + perm.getId()
                    + " has type '" + perm.getType() + "' which is not understood.");
            return response;
        }

        BookingsPeriod period = new BookingsServiceImpl().getFreeBookings(reqStart, reqEnd, perm, db);
        for (BookingSlot slot : period.getSlots()) {
            TimePeriodType tp = new TimePeriodType();
            tp.setStartTime(slot.getStart());
            tp.setEndTime(slot.getEnd());

            BookingSlotType bst = new BookingSlotType();
            bst.setSlot(tp);
            bst.setState(SlotState.Factory.fromValue(slot.getState()));

            slots.addBookingSlot(bst);
        }
    } finally {
        db.close();
    }

    return response;
}