Example usage for org.hibernate.criterion Restrictions eq

Introduction

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

Prototype

public static SimpleExpression eq(String propertyName, Object value) 

Source Link

Document

Apply an "equal" constraint to the named property

Usage

From source file:au.edu.uts.eng.remotelabs.schedserver.permissions.pages.UserClassesPage.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/* w  w w .ja  va 2s . c  o m*/
public void setupView(HttpServletRequest req) {
    /* The view consists of all the existing groups. */
    List<UserClass> userClasses = this.db.createCriteria(UserClass.class).addOrder(Order.desc("active"))
            .addOrder(Order.asc("name")).list();

    Map<Long, List<ResourcePermission>> resourcePermissions = new HashMap<Long, List<ResourcePermission>>(
            userClasses.size());
    for (UserClass uc : userClasses) {
        resourcePermissions.put(uc.getId(),
                this.db.createCriteria(ResourcePermission.class).add(Restrictions.eq("userClass", uc))
                        .addOrder(Order.asc("displayName")).addOrder(Order.desc("type"))
                        .addOrder(Order.desc("rigType")).addOrder(Order.desc("rig"))
                        .addOrder(Order.desc("requestCapabilities")).addOrder(Order.asc("startTime")).list());
    }

    this.context.put("userClasses", userClasses);
    this.context.put("resourcePermissions", resourcePermissions);
}

---

From source file:au.edu.uts.eng.remotelabs.schedserver.permissions.pages.UserClassesPage.java

License:Open Source License

/**
 * Deletes a user class./*from  w w w . j  a v  a  2s  .c o  m*/
 * 
 * @param req request
 * @return response
 * @throws JSONException
 */
public JSONObject deleteClass(HttpServletRequest req) throws JSONException {
    JSONObject response = new JSONObject();
    response.put("wasSuccessful", false);

    String name = req.getParameter("name");
    if (name == null) {
        this.logger.warn("Unable to delete user class because the class name was not specified.");
        response.put("reason", "Name was not specified.");
        return response;
    }

    UserClassDao dao = new UserClassDao(this.db);
    UserClass uc = dao.findByName(name);
    if (uc == null) {
        this.logger.warn("Unable to delete user class because the class '" + name + "' was not found.");
        response.put("reason", "User class was not found.");
        return response;
    }

    this.logger.debug("Attempting to delete user class '" + uc.getName() + "'.");

    int num = (Integer) this.db.createCriteria(Session.class).add(Restrictions.eq("active", Boolean.TRUE))
            .createCriteria("resourcePermission").add(Restrictions.eq("userClass", uc))
            .setProjection(Projections.rowCount()).uniqueResult();
    if (num > 0) {
        this.logger.warn("Unable to delete user class '" + uc.getName()
                + "' because a session from this classes " + "permission is active.");
        response.put("reason", "A session from this class is in progress.");
        return response;
    }

    num = (Integer) this.db.createCriteria(Bookings.class).add(Restrictions.eq("active", Boolean.TRUE))
            .createCriteria("resourcePermission").add(Restrictions.eq("userClass", uc))
            .setProjection(Projections.rowCount()).uniqueResult();
    if (num > 0) {
        this.logger.warn("Unable to delete user class '" + uc.getName()
                + "' because a booking from this classes " + "permission is active.");
        response.put("reason", "User class has active reservations.");
        return response;
    }

    dao.delete(uc);
    this.logger.info("Deleted user class '" + uc.getName() + "'.");

    response.put("wasSuccessful", true);
    return response;
}

---

From source file:au.edu.uts.eng.remotelabs.schedserver.permissions.pages.UserClassesPage.java

License:Open Source License

/**
 * Deletes a permission./*from   w w  w . j ava  2  s.  c o  m*/
 * 
 * @param request
 * @return response
 * @throws JSONException
 */
public JSONObject deletePermission(HttpServletRequest request) throws JSONException {
    JSONObject obj = new JSONObject();
    obj.put("success", false);

    ResourcePermissionDao dao = new ResourcePermissionDao(this.db);

    ResourcePermission perm = dao.get(Long.parseLong(request.getParameter("pid")));
    if (perm == null) {
        this.logger.warn("Unable to delete resource permission with identifier '" + request.getParameter("pid")
                + "' because the permission was not found.");
        obj.put("reason", "Permission not found");
        return obj;
    }

    int num = (Integer) this.db.createCriteria(Session.class).add(Restrictions.eq("active", Boolean.TRUE))
            .add(Restrictions.eq("resourcePermission", perm)).setProjection(Projections.rowCount())
            .uniqueResult();
    if (num > 0) {
        this.logger.warn("Unable to delete resource permission '" + perm.getId()
                + "' because a session from this " + "permission is active.");
        obj.put("reason", "A session from this class is in progress.");
        return obj;
    }

    num = (Integer) this.db.createCriteria(Bookings.class).add(Restrictions.eq("active", Boolean.TRUE))
            .add(Restrictions.eq("resourcePermission", perm)).setProjection(Projections.rowCount())
            .uniqueResult();
    if (num > 0) {
        this.logger.warn("Unable to delete permission '" + perm.getId() + "' because a booking from this "
                + "permission is active.");
        obj.put("reason", "Permission has active reservations.");
        return obj;
    }

    dao.delete(perm);
    this.logger.info("Resource permission '" + perm.getId() + "' has been deleted.");

    obj.put("success", true);
    return obj;
}

---

From source file:au.edu.uts.eng.remotelabs.schedserver.permissions.pages.UsersPage.java

License:Open Source License

/**
 * Gets a list of users with a specific search term. The users may be 
 * excluded from a specific class. /*from   ww w .j  a va2  s  . c  om*/
 * 
 * @param request
 * @return response
 * @throws Exception
 */
@SuppressWarnings("unchecked")
public JSONArray list(HttpServletRequest request) throws JSONException {
    JSONArray arr = new JSONArray();

    Criteria qu = this.db.createCriteria(User.class);

    String search = request.getParameter("search");
    if (search != null) {
        /* Search filter. */
        qu.add(Restrictions.disjunction().add(Restrictions.like("name", search, MatchMode.ANYWHERE))
                .add(Restrictions.like("firstName", search, MatchMode.ANYWHERE))
                .add(Restrictions.like("lastName", search, MatchMode.ANYWHERE)));
    }

    if (request.getParameter("max") != null) {
        /* Max results. */
        qu.setMaxResults(Integer.parseInt(request.getParameter("max")));
    }

    if (request.getParameter("in") != null) {
        /* Users in class. */
        UserClass inClass = new UserClassDao(this.db).findByName(request.getParameter("in"));
        if (inClass == null) {
            this.logger.warn("Not going to add in class as a user list restriction because the class '"
                    + request.getParameter("in") + "' was not found.");
        } else {
            qu.createCriteria("userAssociations").add(Restrictions.eq("userClass", inClass));
        }
    }

    if (request.getParameter("notIn") != null) {
        /* Users not in class. */
        UserClass notInClass = new UserClassDao(this.db).findByName(request.getParameter("notIn"));
        if (notInClass == null) {
            this.logger.warn("Not going to add not in class as a user list restriction because the class '"
                    + request.getParameter("notIn") + "' was not found.");
        } else {
            DetachedCriteria subQu = DetachedCriteria.forClass(User.class)
                    .setProjection(Property.forName("name")).createCriteria("userAssociations")
                    .add(Restrictions.eq("userClass", notInClass));

            List<String> names = subQu.getExecutableCriteria(this.db).list();
            if (names.size() > 0) {
                qu.add(Restrictions.not(Restrictions.in("name", names)));
            }
        }
    }

    qu.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
    qu.addOrder(Order.asc("lastName"));
    qu.addOrder(Order.asc("name"));

    for (User user : (List<User>) qu.list()) {
        JSONObject uo = new JSONObject();
        uo.put("name", user.getNamespace() + "-_-" + user.getName());

        if (user.getFirstName() == null || user.getLastName() == null) {
            uo.put("display", user.getName());
        } else {
            uo.put("display", user.getLastName() + ", " + user.getFirstName());
        }

        arr.put(uo);
    }

    return arr;
}

---

From source file:au.edu.uts.eng.remotelabs.schedserver.queuer.impl.Queue.java

License:Open Source License

/**
 * Runs rig type assigning by loading free rigs in the type and calling
 * rig assignment./*w  w w .  ja  v a  2 s  .c  o  m*/
 *
 * @param id rig type id
 * @param db database session
 */
public synchronized void runTypeAssignment(Long id, org.hibernate.Session db) {
    RigType type = new RigTypeDao(db).get(id);
    if (type == null)
        return;

    /* Create a query to find a free rig in the rig type. */
    Criteria query = db.createCriteria(Rig.class);
    query.add(Restrictions.eq("rigType", type)).add(Restrictions.eq("active", true))
            .add(Restrictions.eq("online", true)).add(Restrictions.eq("inSession", false))
            .addOrder(Order.asc("lastUpdateTimestamp"));

    @SuppressWarnings("unchecked")
    List<Rig> freeRigs = query.list();
    for (Rig freeRig : freeRigs) {
        if (!this.typeQueues.containsKey(id) || this.typeQueues.get(id).size() == 0) {
            return;
        }
        this.runRigAssignment(freeRig.getId(), db);
    }
}

---

From source file:au.edu.uts.eng.remotelabs.schedserver.queuer.impl.QueueStaleSessionTask.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override//  w  ww . ja  v a 2  s. com
public void run() {
    org.hibernate.Session db = null;
    try {
        db = DataAccessActivator.getNewSession();
        Date now = new Date();

        Criteria query = db.createCriteria(Session.class);
        query.add(Restrictions.eq("active", Boolean.TRUE)) // Session must be active.
                .add(Restrictions.isNull("assignmentTime")) // Only sessions in the queue
                .add(Restrictions.isNull("codeReference")); // Only interactive sessions
        List<Session> sessions = query.list();

        /* For each of the sessions, if any of the sessions are stale, remove
         * them from queue. */
        for (Session s : sessions) {
            if ((System.currentTimeMillis() - s.getActivityLastUpdated().getTime()) / 1000 > s
                    .getResourcePermission().getQueueActivityTimeout()) {
                this.logger.warn("Removing stale queue session with id=" + s.getId() + ". Last activity at"
                        + s.getActivityLastUpdated().toString() + ", current time is " + now.toString() + ".");

                Queue.getInstance().removeEntry(s, db);
                s.setActive(false);
                s.setRemovalReason("Queue activity timeout.");
                s.setRemovalTime(now);
                db.beginTransaction();
                db.flush();
                db.getTransaction().commit();
            }
        }
    } catch (HibernateException hex) {
        this.logger.error("Failed to query database to check stale sessions (Exception: "
                + hex.getClass().getName() + ", Message:" + hex.getMessage() + ").");

        if (db != null && db.getTransaction() != null) {
            try {
                db.getTransaction().rollback();
            } catch (HibernateException ex) {
                this.logger.error("Exception rolling back up stale session transaction (Exception: "
                        + ex.getClass().getName() + "," + " Message: " + ex.getMessage() + ").");
            }
        }
    } finally {
        try {
            if (db != null)
                db.close();
        } catch (HibernateException ex) {
            this.logger.error("Exception cleaning up database session (Exception: " + ex.getClass().getName()
                    + "," + " Message: " + ex.getMessage() + ").");
        }
    }
}

---

From source file:au.edu.uts.eng.remotelabs.schedserver.queuer.intf.Queuer.java

License:Open Source License

/**
 * Gets queue information for the specified resource permission.
 * /*from  w  w  w.  j  a  va2 s . c om*/
 * @param perm resource permission
 * @param ses database session
 * @return queue information
 */
@SuppressWarnings("unchecked")
private QueueType getQueueForPermission(ResourcePermission perm, org.hibernate.Session ses) {
    /* Default values. */
    QueueType queue = new QueueType();
    queue.setViable(false);
    queue.setHasFree(false);
    queue.setIsQueuable(false);
    queue.setIsCodeAssignable(false);
    queue.setIsSlaveable(false);
    ResourceIDType resource = new ResourceIDType();
    queue.setQueuedResource(resource);
    resource.setType("NOTFOUND");

    if (perm == null)
        return queue;

    /* Queuable is based on the resource class. */
    boolean rights = perm.getControlLevel().ordinal() > 0;
    queue.setIsQueuable(perm.getUserClass().isQueuable() && rights);
    queue.setIsBookable(perm.getUserClass().isBookable() && rights);
    queue.setIsSlaveable((perm.getControlLevel().ordinal() & 1) == 0);
    String type = perm.getType();
    resource.setType(type);
    boolean free = false;
    if (ResourcePermission.RIG_PERMISSION.equals(type)) {
        /* Rig resource. */
        Rig rig = perm.getRig();
        resource.setResourceID(rig.getId().intValue());
        resource.setResourceName(rig.getName());

        queue.setHasFree(this.isRigFree(rig, perm, ses));
        queue.setViable(rig.isOnline());

        /* Code assignable is defined by the rig type of the rig. */
        queue.setIsCodeAssignable(rig.getRigType().isCodeAssignable());

        /* Only one resource, the actual rig. */
        QueueTargetType target = new QueueTargetType();
        target.setViable(rig.isOnline());
        target.setIsFree(this.isRigFree(rig, perm, ses));
        target.setResource(resource);
        queue.addQueueTarget(target);

    } else if (ResourcePermission.TYPE_PERMISSION.equals(type)) {
        /* Rig type resource. */
        RigType rigType = perm.getRigType();
        resource.setResourceID(rigType.getId().intValue());
        resource.setResourceName(rigType.getName());
        queue.setIsCodeAssignable(rigType.isCodeAssignable());

        /* The targets are the rigs in the rig type. */
        for (Rig rig : rigType.getRigs()) {
            if (rig.isOnline())
                queue.setViable(true);
            if (free = this.isRigFree(rig, perm, ses))
                queue.setHasFree(true);

            QueueTargetType target = new QueueTargetType();
            target.setViable(rig.isOnline());
            target.setIsFree(free);
            ResourceIDType resourceRig = new ResourceIDType();
            resourceRig.setType(ResourcePermission.RIG_PERMISSION);
            resourceRig.setResourceID(rig.getId().intValue());
            resourceRig.setResourceName(rig.getName());
            target.setResource(resourceRig);
            queue.addQueueTarget(target);
        }
    } else if (ResourcePermission.CAPS_PERMISSION.equals(type)) {
        /* Capabilities resource. */
        RequestCapabilities requestCaps = perm.getRequestCapabilities();
        resource.setResourceID(requestCaps.getId().intValue());
        resource.setResourceName(requestCaps.getCapabilities());

        /* For code assignable to be true, all rigs who match the
         * request capabilities, must be code assignable. */
        queue.setIsCodeAssignable(true);

        /* Are all the rigs who have match rig capabilities to the
         * request capabilities. */
        Criteria qu = ses.createCriteria(Rig.class).addOrder(Order.asc("name"))
                .createCriteria("rigCapabilities").createCriteria("matchingCapabilitieses")
                .add(Restrictions.eq("requestCapabilities", requestCaps));

        /* Are all the rigs who have match rig capabilities to the
         * request capabilities. */
        for (Rig capRig : (List<Rig>) qu.list()) {
            if (!capRig.getRigType().isCodeAssignable())
                queue.setIsCodeAssignable(false);

            /* To be viable, only one rig needs to be online. */
            if (capRig.isOnline())
                queue.setViable(true);

            /* To be 'has free', only one rig needs to be free. */
            if (free = this.isRigFree(capRig, perm, ses))
                queue.setHasFree(true);

            /* Add target. */
            QueueTargetType target = new QueueTargetType();
            target.setViable(capRig.isOnline());
            target.setIsFree(free);
            queue.addQueueTarget(target);
            ResourceIDType resTarget = new ResourceIDType();
            resTarget.setType(ResourcePermission.RIG_PERMISSION);
            resTarget.setResourceID(capRig.getId().intValue());
            resTarget.setResourceName(capRig.getName());
            target.setResource(resTarget);
        }
    }

    return queue;
}

---

From source file:au.edu.uts.eng.remotelabs.schedserver.queuer.intf.Queuer.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override//ww  w.  j a  v a2  s  .co  m
public CheckResourceAvailabilityResponse checkResourceAvailability(final CheckResourceAvailability request) {
    /* Request parameters. */
    ResourceIDType resReq = request.getCheckResourceAvailability();
    long rId = resReq.getResourceID();
    String type = resReq.getType(), name = resReq.getResourceName();
    this.logger.debug("Received " + this.getClass().getSimpleName() + "#checkResourceAvailability with params "
            + "resource type=" + type + ", resource identifier=" + rId + ", resource name=" + name + '.');

    /* Response parameters. */
    CheckResourceAvailabilityResponse resp = new CheckResourceAvailabilityResponse();
    QueueType queue = new QueueType();
    resp.setCheckResourceAvailabilityResponse(queue);
    queue.setViable(false);
    queue.setHasFree(false);
    queue.setIsCodeAssignable(false);

    /* This is always true because queueable/bookab;e is stored as a user 
     * class permission. There isn't enough information to determine this
     * so the best case is assumed. */
    queue.setIsQueuable(true);
    queue.setIsBookable(true);

    ResourceIDType resource = new ResourceIDType();
    queue.setQueuedResource(resource);
    resource.setType(type);

    if (!this.checkPermission(resReq)) {
        this.logger.warn("Unable to provide resource information because of insufficient permission.");
        return resp;
    }

    RigDao rigDao = new RigDao();
    try {
        Rig rig;
        RigTypeDao typeDao = new RigTypeDao(rigDao.getSession());
        RigType rigType;
        RequestCapabilitiesDao capsDao = new RequestCapabilitiesDao(rigDao.getSession());
        RequestCapabilities requestCaps;
        if (ResourcePermission.RIG_PERMISSION.equals(type) && ((rId > 0 && (rig = rigDao.get(rId)) != null)
                || (name != null && (rig = rigDao.findByName(name)) != null))) {
            /* Rig resource. */
            resource.setResourceID(rig.getId().intValue());
            resource.setResourceName(rig.getName());

            queue.setHasFree(rig.isOnline() && !rig.isInSession());
            queue.setViable(rig.isOnline());

            /* Code assignable is defined by the rig type of the rig. */
            queue.setIsCodeAssignable(rig.getRigType().isCodeAssignable());

            /* Only one resource, the actual rig. */
            QueueTargetType target = new QueueTargetType();
            target.setViable(rig.isOnline());
            target.setIsFree(rig.isOnline() && !rig.isInSession());
            target.setResource(resource);
            queue.addQueueTarget(target);

        } else if (ResourcePermission.TYPE_PERMISSION.equals(type)
                && ((rId > 0 && (rigType = typeDao.get(rId)) != null)
                        || (name != null && (rigType = typeDao.findByName(name)) != null))) {
            /* Rig type resource. */
            resource.setResourceID(rigType.getId().intValue());
            resource.setResourceName(rigType.getName());

            queue.setIsCodeAssignable(rigType.isCodeAssignable());

            /* The targets are the rigs in the rig type. */
            for (Rig r : rigType.getRigs()) {
                if (r.isOnline())
                    queue.setViable(true);
                if (r.isOnline() && !r.isInSession())
                    queue.setHasFree(true);

                QueueTargetType target = new QueueTargetType();
                target.setViable(r.isOnline());
                target.setIsFree(r.isOnline() && !r.isInSession());
                ResourceIDType resourceRig = new ResourceIDType();
                resourceRig.setType(ResourcePermission.RIG_PERMISSION);
                resourceRig.setResourceID(r.getId().intValue());
                resourceRig.setResourceName(r.getName());
                target.setResource(resourceRig);
                queue.addQueueTarget(target);
            }
        } else if (ResourcePermission.CAPS_PERMISSION.equals(type)
                && ((rId > 0 && (requestCaps = capsDao.get(rId)) != null)
                        || (name != null && (requestCaps = capsDao.findCapabilites(name)) != null))) {
            /* Capabilities resource. */
            resource.setResourceID(requestCaps.getId().intValue());
            resource.setResourceName(requestCaps.getCapabilities());

            /* For code assignable to be true, all rigs who match the
             * request capabilities, must be code assignable. */
            queue.setIsCodeAssignable(true);

            /* Are all the rigs who have match rig capabilities to the
             * request capabilities. */
            Criteria qu = rigDao.getSession().createCriteria(Rig.class).addOrder(Order.asc("name"))
                    .createCriteria("rigCapabilities").createCriteria("matchingCapabilitieses")
                    .add(Restrictions.eq("requestCapabilities", requestCaps));

            for (Rig capRig : (List<Rig>) qu.list()) {
                if (!capRig.getRigType().isCodeAssignable())
                    queue.setIsCodeAssignable(false);

                /* To be viable, only one rig needs to be online. */
                if (capRig.isOnline())
                    queue.setViable(true);

                /* To be 'has free', only one rig needs to be free. */
                if (capRig.isOnline() && !capRig.isInSession())
                    queue.setHasFree(true);

                /* Add target. */
                QueueTargetType target = new QueueTargetType();
                target.setViable(capRig.isOnline());
                target.setIsFree(capRig.isOnline() && !capRig.isInSession());
                queue.addQueueTarget(target);
                ResourceIDType resTarget = new ResourceIDType();
                resTarget.setType(ResourcePermission.RIG_PERMISSION);
                resTarget.setResourceID(capRig.getId().intValue());
                resTarget.setResourceName(capRig.getName());
                target.setResource(resTarget);
            }
        } else {
            this.logger.info(
                    "Unable to find resource of type " + type + " with ID " + rId + " and name " + name + '.');
            resource.setType("NOTFOUND");
        }
    } finally {
        rigDao.closeSession();
    }

    return resp;
}

---

From source file:au.edu.uts.eng.remotelabs.schedserver.queuer.intf.Queuer.java

License:Open Source License

/**
 * Gets the next user bookingService within a specified limit, from now to now
 * plus limit. If no bookingService exists within the limit, null is returned.
 * //from ww w  .ja  v  a  2 s .  c o m
 * @param user user who has bookingService
 * @param sec limit 
 * @param ses database session
 * @return bookingService or null if none exists 
 */
private Bookings getNextBooking(User user, int sec, org.hibernate.Session ses) {
    Calendar start = Calendar.getInstance();
    start.add(Calendar.SECOND, sec);

    return (Bookings) ses.createCriteria(Bookings.class).add(Restrictions.eq("active", Boolean.TRUE))
            .add(Restrictions.eq("user", user)).add(Restrictions.lt("startTime", start.getTime()))
            .setMaxResults(1).addOrder(Order.asc("startTime")).uniqueResult();
}

---

From source file:au.edu.uts.eng.remotelabs.schedserver.reports.intf.Reports.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override//from  w  w w .  j a  v a2  s .  co m
public QueryInfoResponse queryInfo(final QueryInfo queryInfo) {
    /** Request parameters. **/
    final QueryInfoType qIReq = queryInfo.getQueryInfo();
    String debug = "Received " + this.getClass().getSimpleName() + "#queryInfo with params:";
    debug += "Requestor: " + qIReq.getRequestor() + ", QuerySelect: " + qIReq.getQuerySelect();
    if (qIReq.getQueryFilter() != null) {
        debug += ", QueryFilter: " + qIReq.getQueryFilter();
    }
    debug += ", limit: " + qIReq.getLimit();
    this.logger.debug(debug);
    final RequestorType uid = qIReq.getRequestor();

    /** Response parameters. */
    final QueryInfoResponse resp = new QueryInfoResponse();
    final QueryInfoResponseType respType = new QueryInfoResponseType();
    respType.setTypeForQuery(TypeForQuery.RIG);
    resp.setQueryInfoResponse(respType);

    final org.hibernate.Session ses = DataAccessActivator.getNewSession();

    /* First Query Filter - this contains the main selection type to be selected */
    final QueryFilterType query0 = qIReq.getQuerySelect();

    try {
        Criteria cri;

        /* ----------------------------------------------------------------
         * -- Load the requestor.                                             --
         * ---------------------------------------------------------------- */
        final User user = this.getUserFromUserID(uid, ses);
        if (user == null) {
            this.logger.info("Unable to generate report because the user has not been found. Supplied "
                    + "credentials ID=" + uid.getUserID() + ", namespace=" + uid.getUserNamespace() + ", "
                    + "name=" + uid.getUserName() + '.');
            return resp;
        }
        final String persona = user.getPersona();

        /* Check for type of query to determine selection parameters */
        if (query0.getTypeForQuery() == TypeForQuery.RIG) {
            /* ----------------------------------------------------------------
             * -- Rig Information only available to ADMIN, to be mediated    --
             * -- by interface. No criteria on Requestor                     --
             * ---------------------------------------------------------------- */

            cri = ses.createCriteria(Rig.class);
            if (query0.getQueryLike() != null) {
                cri.add(Restrictions.like("name", query0.getQueryLike(), MatchMode.ANYWHERE));
            }
            if (qIReq.getLimit() > 0)
                cri.setMaxResults(qIReq.getLimit());

            cri.addOrder(Order.asc("name"));
            for (final Rig o : (List<Rig>) cri.list()) {
                respType.addSelectionResult(o.getName());
            }
        } else if (query0.getTypeForQuery() == TypeForQuery.RIG_TYPE) {
            /* ----------------------------------------------------------------
             * -- Rig Type Information only available to ADMIN, to be        -- 
             * -- mediated by interface. No criteria on Requestor            --
             * ---------------------------------------------------------------- */
            cri = ses.createCriteria(RigType.class);

            if (query0.getQueryLike() != null) {
                cri.add(Restrictions.like("name", query0.getQueryLike(), MatchMode.ANYWHERE));
            }
            if (qIReq.getLimit() > 0)
                cri.setMaxResults(qIReq.getLimit());
            cri.addOrder(Order.asc("name"));
            for (final RigType o : (List<RigType>) cri.list()) {
                respType.addSelectionResult(o.getName());
            }
        } else if (query0.getTypeForQuery() == TypeForQuery.USER_CLASS) {
            cri = ses.createCriteria(UserClass.class);

            if (query0.getQueryLike() != null) {
                cri.add(Restrictions.like("name", query0.getQueryLike(), MatchMode.ANYWHERE));
            }
            if (qIReq.getLimit() > 0)
                cri.setMaxResults(qIReq.getLimit());
            cri.addOrder(Order.asc("name"));

            /* ----------------------------------------------------------------
            * Check that the requestor has permissions to request the report.
            * If persona = USER, no reports (USERs will not get here)
            * If persona = ADMIN, any report 
            * If persona = ACADEMIC, only for classes they own if they can generate reports
            * ---------------------------------------------------------------- */

            if (User.ACADEMIC.equals(persona)) {
                DetachedCriteria apList = DetachedCriteria.forClass(AcademicPermission.class, "ap")
                        .add(Restrictions.eq("ap.canGenerateReports", true))
                        .setProjection(Property.forName("userClass"));

                cri.add(Subqueries.propertyIn("id", apList));

                for (final UserClass o : (List<UserClass>) cri.list()) {
                    respType.addSelectionResult(o.getName());
                }
            } else if (User.ADMIN.equals(persona)) {
                for (final UserClass o : (List<UserClass>) cri.list()) {
                    respType.addSelectionResult(o.getName());
                }
            }
        } else if (query0.getTypeForQuery() == TypeForQuery.USER) {
            cri = ses.createCriteria(User.class, "u");

            /* ----------------------------------------------------------------
             * If persona = USER, no reports (USERs will not get here)
             * If persona = ADMIN, any report 
             * If persona = ACADEMIC, only for users in classes they own if they can genrate reports
             * ---------------------------------------------------------------- */

            if (query0.getQueryLike() != null) {
                cri.add(Restrictions.like("name", query0.getQueryLike(), MatchMode.ANYWHERE));
            }
            if (qIReq.getLimit() > 0)
                cri.setMaxResults(qIReq.getLimit());
            cri.addOrder(Order.asc("name"));

            if (User.ACADEMIC.equals(persona)) {
                DetachedCriteria apList = DetachedCriteria.forClass(AcademicPermission.class, "ap")
                        .add(Restrictions.eq("ap.canGenerateReports", true))
                        .setProjection(Property.forName("userClass"));

                DetachedCriteria userList = DetachedCriteria.forClass(UserAssociation.class, "ua")
                        .add(Subqueries.propertyIn("ua.userClass", apList))
                        .setProjection(Property.forName("user.id"));

                cri.add(Subqueries.propertyIn("id", userList));

                for (final User o : (List<User>) cri.list()) {
                    respType.addSelectionResult(o.getNamespace() + ':' + o.getName());
                }
            } else if (User.ADMIN.equals(persona)) {
                for (final User o : (List<User>) cri.list()) {
                    respType.addSelectionResult(o.getNamespace() + ':' + o.getName());
                }
            }
        } else if (query0.getTypeForQuery() == TypeForQuery.REQUEST_CAPABILITIES) {
            cri = ses.createCriteria(RequestCapabilities.class);
            if (query0.getQueryLike() != null) {
                cri.add(Restrictions.like("capabilities", query0.getQueryLike(), MatchMode.ANYWHERE));
            }
            if (qIReq.getLimit() > 0)
                cri.setMaxResults(qIReq.getLimit());
            cri.addOrder(Order.asc("capabilities"));
            final List<RequestCapabilities> list = cri.list();
            for (final RequestCapabilities o : list) {
                respType.addSelectionResult(o.getCapabilities());
            }
        } else {
            this.logger.error(
                    "QueryInfo request failed because TypeForQuery does not have a valid value.  Value is "
                            + query0.getTypeForQuery().toString());
            return resp;
        }

        final QueryFilterType filter[] = qIReq.getQueryFilter();
        if (filter != null) {
            //DODGY Designed, not implemented
        }
    } finally {
        ses.close();
    }

    respType.setTypeForQuery(query0.getTypeForQuery());
    resp.setQueryInfoResponse(respType);

    return resp;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »