Example usage for org.hibernate.criterion Restrictions between

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

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

Introduction

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

Prototype

public static Criterion between(String propertyName, Object low, Object high)

Source Link

Document

Apply a "between" constraint to the named property

Usage

From source file:de.lemo.dms.processing.questions.QPerformanceBoxPlot.java

License:Open Source License

/**
 * @param courses//from   ww  w .  j  ava 2 s .c  o m
 *            (optional) List of course-ids that shall be included
 * @param users
 *            (optional) List of user-ids
 * @param quizzes
 *            (mandatory) List of the tuples: every learning object has successive entries, first the prefix of the
 *            learning-object-type (11 for "assignment", 14 for "quiz", 17 for "scorm") and the objects id
 * @param resolution
 *            (mandatory)
 * @param startTime
 *            (mandatory)
 * @param endTime
 *            (mandatory)
 * @return
 */
@SuppressWarnings("unchecked")
@POST
public ResultListBoxPlot compute(@FormParam(MetaParam.COURSE_IDS) final List<Long> courses,
        @FormParam(MetaParam.USER_IDS) List<Long> users, @FormParam(MetaParam.QUIZ_IDS) List<Long> quizzes,
        @FormParam(MetaParam.RESOLUTION) final Long resolution,
        @FormParam(MetaParam.START_TIME) final Long startTime,
        @FormParam(MetaParam.END_TIME) final Long endTime,
        @FormParam(MetaParam.GENDER) final List<Long> gender) {

    validateTimestamps(startTime, endTime, resolution);

    if (logger.isDebugEnabled()) {
        if ((courses != null) && (courses.size() > 0)) {
            StringBuffer buffer = new StringBuffer();
            buffer.append("Parameter list: Courses: " + courses.get(0));
            for (int i = 1; i < courses.size(); i++) {
                buffer.append(", " + courses.get(i));
            }
            logger.debug(buffer.toString());
        }
        if ((users != null) && (users.size() > 0)) {
            StringBuffer buffer = new StringBuffer();
            buffer.append("Parameter list: Users: " + users.get(0));
            for (int i = 1; i < users.size(); i++) {
                buffer.append(", " + users.get(i));
            }
            logger.debug(buffer.toString());
        }
        logger.debug("Parameter list: Start time: : " + startTime);
        logger.debug("Parameter list: End time: : " + endTime);
    }

    final HashMap<Long, ArrayList<Double>> values = new HashMap<Long, ArrayList<Double>>();

    final IDBHandler dbHandler = ServerConfiguration.getInstance().getMiningDbHandler();
    final Session session = dbHandler.getMiningSession();

    Criteria criteria;
    if (users == null || users.size() == 0) {
        users = new ArrayList<Long>(StudentHelper.getCourseStudentsAliasKeys(courses, gender).values());
    } else {
        Map<Long, Long> userMap = StudentHelper.getCourseStudentsAliasKeys(courses, gender);
        List<Long> tmp = new ArrayList<Long>();
        for (int i = 0; i < users.size(); i++) {
            tmp.add(userMap.get(users.get(i)));
        }
        users = tmp;
    }

    criteria = session.createCriteria(IRatedLogObject.class, "log");
    criteria.add(Restrictions.between("log.timestamp", startTime, endTime));
    if ((courses != null) && (courses.size() > 0)) {
        criteria.add(Restrictions.in("log.course.id", courses));
    }
    if ((users != null) && (users.size() > 0)) {
        criteria.add(Restrictions.in("log.user.id", users));
    }

    final ArrayList<IRatedLogObject> list = (ArrayList<IRatedLogObject>) criteria.list();

    final HashMap<String, IRatedLogObject> singleResults = new HashMap<String, IRatedLogObject>();
    Collections.sort(list);

    // This is for making sure there is just one entry per student and test
    for (int i = list.size() - 1; i >= 0; i--) {
        final IRatedLogObject log = list.get(i);

        final String key = log.getPrefix() + " " + log.getLearnObjId() + " " + log.getUser().getId();
        if ((quizzes.size() == 0)
                || quizzes.contains(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId()))) {
            if ((singleResults.get(key) == null) && (log.getFinalGrade() != null)
                    && (log.getMaxGrade() != null)) {
                if (values.get(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId())) == null) {
                    final ArrayList<Double> v = new ArrayList<Double>();
                    values.put(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId()), v);
                }
                singleResults.put(key, log);
            }
        }
    }

    for (final IRatedLogObject log : singleResults.values()) {
        final Long name = Long.valueOf(log.getPrefix() + "" + log.getLearnObjId());
        if (values.get(name) == null) {
            final ArrayList<Double> v = new ArrayList<Double>();
            values.put(name, v);
        }

        values.get(name).add(log.getFinalGrade() / ((log.getMaxGrade() / resolution)));
    }

    BoxPlot[] results = new BoxPlot[values.keySet().size()];

    int i = 0;
    for (final Entry<Long, ArrayList<Double>> e : values.entrySet()) {

        final BoxPlot plotty = this.calcBox(e.getValue(), e.getKey());
        results[i] = plotty;
        i++;
    }
    session.close();
    return new ResultListBoxPlot(Arrays.asList(results));
}

From source file:de.lemo.dms.processing.questions.QPerformanceHistogram.java

License:Open Source License

/**
 * @param courses// w  w  w .jav a2  s . c  om
 *            (optional) List of course-ids that shall be included
 * @param users
 *            (optional) List of user-ids
 * @param quizzes
 *            (mandatory) List of learning object ids (the ids have to start with the type specific prefix (11 for
 *            "assignment", 14 for "quiz", 17 for "scorm"))
 * @param resolution
 *            (mandatory)
 * @param startTime
 *            (mandatory)
 * @param endTime
 *            (mandatory)
 * @return
 */
@SuppressWarnings("unchecked")
@POST
public ResultListLongObject compute(@FormParam(MetaParam.COURSE_IDS) final List<Long> courses,
        @FormParam(MetaParam.USER_IDS) List<Long> users,
        @FormParam(MetaParam.QUIZ_IDS) final List<Long> quizzes,
        @FormParam(MetaParam.RESOLUTION) final Long resolution,
        @FormParam(MetaParam.START_TIME) final Long startTime,
        @FormParam(MetaParam.END_TIME) final Long endTime,
        @FormParam(MetaParam.GENDER) final List<Long> gender) {

    validateTimestamps(startTime, endTime, resolution);

    if (logger.isDebugEnabled()) {
        if ((courses != null) && (courses.size() > 0)) {
            StringBuffer buffer = new StringBuffer();
            buffer.append("Parameter list: Courses: " + courses.get(0));
            for (int i = 1; i < courses.size(); i++) {
                buffer.append(", " + courses.get(i));
            }
            logger.debug(buffer.toString());
        }
        if ((users != null) && (users.size() > 0)) {
            StringBuffer buffer = new StringBuffer();
            buffer.append("Parameter list: Users: " + users.get(0));
            for (int i = 1; i < users.size(); i++) {
                buffer.append(", " + users.get(i));
            }
            logger.debug(buffer.toString());
        }
        logger.debug("Parameter list: Resolution: : " + resolution);
        logger.debug("Parameter list: Start time: : " + startTime);
        logger.debug("Parameter list: End time: : " + endTime);
    }

    final Map<Long, Integer> obj = new HashMap<Long, Integer>();

    if (quizzes.size() > 0) {
        for (int i = 0; i < quizzes.size(); i++) {
            obj.put(quizzes.get(i), i);
        }
    } else {
        ServiceRatedObjects sro = new ServiceRatedObjects();
        ResultListStringObject rso = sro.getRatedObjects(courses);
        String s = new String();
        int count = 0;
        for (int i = 0; i < rso.getElements().size(); i++) {
            if ((i + 1) % 3 != 0) {
                s += rso.getElements().get(i);
            } else {
                obj.put(Long.valueOf(s), count);
                quizzes.add(Long.valueOf(s));
                s = "";
                count++;
            }
        }

    }

    // Determine length of result array
    final int objects = resolution.intValue() * quizzes.size();

    final Long[] results = new Long[objects];
    // Initialize result array
    for (int i = 0; i < results.length; i++) {
        results[i] = 0L;
    }

    final IDBHandler dbHandler = ServerConfiguration.getInstance().getMiningDbHandler();
    final Session session = dbHandler.getMiningSession();

    Criteria criteria;
    if (users == null || users.size() == 0) {
        users = new ArrayList<Long>(StudentHelper.getCourseStudentsAliasKeys(courses, gender).values());
    } else {
        Map<Long, Long> userMap = StudentHelper.getCourseStudentsAliasKeys(courses, gender);
        List<Long> tmp = new ArrayList<Long>();
        for (int i = 0; i < users.size(); i++) {
            tmp.add(userMap.get(users.get(i)));
        }
        users = tmp;
    }

    criteria = session.createCriteria(IRatedLogObject.class, "log");
    criteria.add(Restrictions.between("log.timestamp", startTime, endTime));
    if ((courses != null) && (courses.size() > 0)) {
        criteria.add(Restrictions.in("log.course.id", courses));
    }
    if ((users != null) && (users.size() > 0)) {
        criteria.add(Restrictions.in("log.user.id", users));
    }

    final ArrayList<IRatedLogObject> list = (ArrayList<IRatedLogObject>) criteria.list();

    final Map<String, IRatedLogObject> singleResults = new HashMap<String, IRatedLogObject>();
    Collections.sort(list);

    // This is for making sure there is just one entry per student and test
    for (int i = list.size() - 1; i >= 0; i--) {
        final IRatedLogObject log = list.get(i);

        final String key = log.getPrefix() + " " + log.getLearnObjId() + " " + log.getUser().getId();

        if (log.getGrade() != null
                && (singleResults.get(key) == null || log.getGrade() > singleResults.get(key).getGrade())) {
            singleResults.put(key, log);
        }
    }

    for (final IRatedLogObject log : singleResults.values()) {
        if ((obj.get(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId())) != null)
                && (log.getFinalGrade() != null) && (log.getMaxGrade() != null) && (log.getMaxGrade() > 0)) {
            // Determine size of each interval
            final Double step = log.getMaxGrade() / resolution;
            if (step > 0d) {
                // Determine interval for specific grade
                int pos = (int) (log.getFinalGrade() / step);
                if (pos > (resolution - 1)) {
                    pos = resolution.intValue() - 1;
                }
                // Increase count of specified interval
                results[(resolution.intValue()
                        * obj.get(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId())))
                        + pos] = results[(resolution.intValue()
                                * obj.get(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId()))) + pos] + 1;
            }
        }
    }
    session.close();
    return new ResultListLongObject(Arrays.asList(results));
}

From source file:de.lemo.dms.processing.questions.QPerformanceUserTest.java

License:Open Source License

/**
 * @param courses/*from ww w.  j a v a2s.  c om*/
 *            (optional) List of course-ids that shall be included
 * @param users
 *            (optional) List of user-ids
 * @param quizzes
 *            (mandatory) List of learning object ids (the ids have to start with the type specific prefix (11 for
 *            "assignment", 14 for "quiz", 17 for "scorm"))
 * @param resolution
 *            (mandatory) Used to scale the results. If set to 0, the method 
 *            returns the actual results of the test. Otherwise it returns the 
 *            results scaled using the value of resolution.
 * @param startTime
 *            (mandatory)
 * @param endTime
 *            (mandatory)
 * @return
 */
@SuppressWarnings("unchecked")
@POST
public ResultListLongObject compute(@FormParam(MetaParam.COURSE_IDS) final List<Long> courses,
        @FormParam(MetaParam.USER_IDS) List<Long> users,
        @FormParam(MetaParam.QUIZ_IDS) final List<Long> quizzes,
        @FormParam(MetaParam.RESOLUTION) final Long resolution,
        @FormParam(MetaParam.START_TIME) final Long startTime,
        @FormParam(MetaParam.END_TIME) final Long endTime,
        @FormParam(MetaParam.GENDER) final List<Long> gender) {

    if (logger.isDebugEnabled()) {
        if ((courses != null) && (courses.size() > 0)) {
            StringBuffer buffer = new StringBuffer();
            buffer.append("Parameter list: Courses: " + courses.get(0));
            for (int i = 1; i < courses.size(); i++) {
                buffer.append(", " + courses.get(i));
            }
            logger.debug(buffer.toString());
        }
        if ((users != null) && (users.size() > 0)) {
            StringBuffer buffer = new StringBuffer();
            buffer.append("Parameter list: Users: " + users.get(0));
            for (int i = 1; i < users.size(); i++) {
                buffer.append(", " + users.get(i));
            }
            logger.debug(buffer.toString());
        }
        logger.debug("Parameter list: Resolution: : " + resolution);
        logger.debug("Parameter list: Start time: : " + startTime);
        logger.debug("Parameter list: End time: : " + endTime);
    }

    final IDBHandler dbHandler = ServerConfiguration.getInstance().getMiningDbHandler();
    final Session session = dbHandler.getMiningSession();

    Criteria criteria;
    if (users == null || users.size() == 0) {
        users = new ArrayList<Long>(StudentHelper.getCourseStudentsAliasKeys(courses, gender).values());
    } else {
        Map<Long, Long> userMap = StudentHelper.getCourseStudentsAliasKeys(courses, gender);
        List<Long> tmp = new ArrayList<Long>();
        for (int i = 0; i < users.size(); i++) {
            tmp.add(userMap.get(users.get(i)));
        }
        users = tmp;
    }
    criteria = session.createCriteria(IRatedLogObject.class, "log");
    criteria.add(Restrictions.between("log.timestamp", startTime, endTime));
    if ((courses != null) && (courses.size() > 0)) {
        criteria.add(Restrictions.in("log.course.id", courses));
    }
    if (users != null && users.size() > 0)
        criteria.add(Restrictions.in("log.user.id", users));

    final ArrayList<IRatedLogObject> list = (ArrayList<IRatedLogObject>) criteria.list();

    final Map<Long, Integer> obj = new HashMap<Long, Integer>();

    if (quizzes.size() > 0) {
        for (int i = 0; i < quizzes.size(); i++) {
            obj.put(quizzes.get(i), i);
        }
    } else {
        ServiceRatedObjects sro = new ServiceRatedObjects();
        ResultListStringObject rso = sro.getRatedObjects(courses);
        String s = new String();
        int count = 0;
        for (int i = 0; i < rso.getElements().size(); i++) {
            if ((i + 1) % 3 != 0) {
                s += rso.getElements().get(i);
            } else {
                obj.put(Long.valueOf(s), count);
                quizzes.add(Long.valueOf(s));
                s = "";
                count++;
            }
        }

    }

    final Map<String, IRatedLogObject> singleResults = new HashMap<String, IRatedLogObject>();
    Collections.sort(list);

    Set<Long> u = new HashSet<Long>();

    // This is for making sure there is just one entry per student and test
    for (int i = list.size() - 1; i >= 0; i--) {
        final IRatedLogObject log = list.get(i);

        final String key = log.getPrefix() + " " + log.getLearnObjId() + " " + log.getUser().getId();

        u.add(log.getUser().getId());

        if (log.getFinalGrade() != null && (singleResults.get(key) == null
                || (log.getFinalGrade() > singleResults.get(key).getFinalGrade()))) {
            singleResults.put(key, log);
        }
    }

    // Determine length of result array
    final int objects = quizzes.size() + u.size() * quizzes.size() + u.size();

    final Long[] results = new Long[objects];

    Map<Long, ArrayList<Long>> fin = new HashMap<Long, ArrayList<Long>>();

    for (final IRatedLogObject log : singleResults.values()) {
        if ((obj.get(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId())) != null)
                && (log.getFinalGrade() != null) && (log.getMaxGrade() != null) && (log.getMaxGrade() > 0)) {
            Double step = 1d;
            // Determine size of each interval
            if (resolution != 0)
                step = log.getMaxGrade() / resolution;
            if (step > 0d) {
                // Determine interval for specific grade
                Integer pos = (int) (log.getFinalGrade() / step);
                if (resolution > 0 && pos > (resolution - 1)) {
                    pos = resolution.intValue() - 1;
                }

                if (fin.get(log.getUser().getId()) == null) {
                    ArrayList<Long> l = new ArrayList<Long>();
                    for (int i = 0; i < quizzes.size(); i++) {
                        l.add(-1L);
                    }
                    fin.put(log.getUser().getId(), l);
                    fin.get(log.getUser().getId()).set(
                            quizzes.indexOf(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId())),
                            pos.longValue());
                } else {
                    fin.get(log.getUser().getId()).set(
                            quizzes.indexOf(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId())),
                            pos.longValue());
                }
            }

        }

    }

    criteria = session.createCriteria(ICourseRatedObjectAssociation.class, "aso");
    criteria.add(Restrictions.in("aso.course.id", courses));

    ArrayList<ICourseRatedObjectAssociation> q = (ArrayList<ICourseRatedObjectAssociation>) criteria.list();
    HashMap<Long, Double> maxGrades = new HashMap<Long, Double>();
    for (ICourseRatedObjectAssociation aso : q) {
        maxGrades.put(Long.valueOf(aso.getPrefix() + "" + aso.getRatedObject().getId()),
                aso.getRatedObject().getMaxGrade());
    }

    //Determine maximum number of points for every quiz
    for (int i = 0; i < quizzes.size(); i++) {
        if (maxGrades.get(quizzes.get(i)) != null)
            results[i] = maxGrades.get(quizzes.get(i)).longValue();
        else
            results[i] = -1L;
    }

    int i = quizzes.size();
    Map<Long, Long> idToAlias = StudentHelper.getCourseStudentsRealKeys(courses, gender);
    for (Entry<Long, ArrayList<Long>> entry : fin.entrySet()) {
        //Insert user-id into result list
        results[i] = idToAlias.get(entry.getKey());
        //Insert all test results for user to result list
        for (Long l : entry.getValue()) {
            i++;
            results[i] = l;
        }
        i++;
    }
    session.close();
    return new ResultListLongObject(Arrays.asList(results));
}

From source file:de.lemo.dms.processing.questions.QPerformanceUserTestBoxPlot.java

License:Open Source License

/**
 * @param courses//from   ww  w  . ja  v  a 2s.c  o  m
 *            (optional) List of course-ids that shall be included
 * @param users
 *            (optional) List of user-ids
 * @param quizzes
 *            (mandatory) List of learning object ids (the ids have to start with the type specific prefix (11 for
 *            "assignment", 14 for "quiz", 17 for "scorm"))
 * @param resolution
 *            (mandatory) Used to scale the results. If set to 0, the method 
 *            returns the actual results of the test. Otherwise it returns the 
 *            results scaled using the value of resolution.
 * @param startTime
 *            (mandatory)
 * @param endTime
 *            (mandatory)
 * @return
 */
@SuppressWarnings("unchecked")
@POST
public ResultListBoxPlot compute(@FormParam(MetaParam.COURSE_IDS) final List<Long> courses,
        @FormParam(MetaParam.USER_IDS) List<Long> users,
        @FormParam(MetaParam.QUIZ_IDS) final List<Long> quizzes,
        @FormParam(MetaParam.RESOLUTION) Long resolution, @FormParam(MetaParam.START_TIME) final Long startTime,
        @FormParam(MetaParam.END_TIME) final Long endTime,
        @FormParam(MetaParam.GENDER) final List<Long> gender) {

    if (logger.isDebugEnabled()) {
        if ((courses != null) && (courses.size() > 0)) {
            StringBuffer buffer = new StringBuffer();
            buffer.append("Parameter list: Courses: " + courses.get(0));
            for (int i = 1; i < courses.size(); i++) {
                buffer.append(", " + courses.get(i));
            }
            logger.debug(buffer.toString());
        }
        if ((users != null) && (users.size() > 0)) {
            StringBuffer buffer = new StringBuffer();
            buffer.append("Parameter list: Users: " + users.get(0));
            for (int i = 1; i < users.size(); i++) {
                buffer.append(", " + users.get(i));
            }
            logger.debug(buffer.toString());
        }
        logger.debug("Parameter list: Resolution: : " + resolution);
        logger.debug("Parameter list: Start time: : " + startTime);
        logger.debug("Parameter list: End time: : " + endTime);
    }

    final IDBHandler dbHandler = ServerConfiguration.getInstance().getMiningDbHandler();
    final Session session = dbHandler.getMiningSession();

    Criteria criteria;
    if (users == null || users.size() == 0) {
        users = new ArrayList<Long>(StudentHelper.getCourseStudentsAliasKeys(courses, gender).values());
    } else {
        Map<Long, Long> userMap = StudentHelper.getCourseStudentsAliasKeys(courses, gender);
        List<Long> tmp = new ArrayList<Long>();
        for (int i = 0; i < users.size(); i++) {
            tmp.add(userMap.get(users.get(i)));
        }
        users = tmp;
    }

    criteria = session.createCriteria(IRatedLogObject.class, "log");
    criteria.add(Restrictions.between("log.timestamp", startTime, endTime));
    if ((courses != null) && (courses.size() > 0)) {
        criteria.add(Restrictions.in("log.course.id", courses));
    }
    if (users != null && users.size() > 0)
        criteria.add(Restrictions.in("log.user.id", users));

    final ArrayList<IRatedLogObject> list = (ArrayList<IRatedLogObject>) criteria.list();

    final Map<Long, Integer> obj = new HashMap<Long, Integer>();

    if (quizzes.size() > 0) {
        for (int i = 0; i < quizzes.size(); i++) {
            obj.put(quizzes.get(i), i);
        }
    } else {
        ServiceRatedObjects sro = new ServiceRatedObjects();
        ResultListStringObject rso = sro.getRatedObjects(courses);
        String s = new String();
        int count = 0;
        for (int i = 0; i < rso.getElements().size(); i++) {
            if ((i + 1) % 3 != 0) {
                s += rso.getElements().get(i);
            } else {
                obj.put(Long.valueOf(s), count);
                quizzes.add(Long.valueOf(s));
                s = "";
                count++;
            }
        }

    }

    final Map<String, IRatedLogObject> singleResults = new HashMap<String, IRatedLogObject>();
    Collections.sort(list);

    Set<Long> u = new HashSet<Long>();

    // This is for making sure there is just one entry per student and test
    for (int i = list.size() - 1; i >= 0; i--) {
        final IRatedLogObject log = list.get(i);

        final String key = log.getPrefix() + " " + log.getLearnObjId() + " " + log.getUser().getId();

        u.add(log.getUser().getId());

        if (log.getFinalGrade() != null && (singleResults.get(key) == null
                || log.getFinalGrade() > singleResults.get(key).getFinalGrade())) {
            singleResults.put(key, log);

        }
    }
    Map<Long, ArrayList<Double>> fin = new HashMap<Long, ArrayList<Double>>();

    for (final IRatedLogObject log : singleResults.values()) {
        if ((obj.get(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId())) != null)
                && (log.getFinalGrade() != null) && (log.getMaxGrade() != null) && (log.getMaxGrade() > 0)) {
            Double step;
            // Determine size of each interval
            if (resolution == null || resolution == 0)
                resolution = 100L;
            step = log.getMaxGrade() / resolution;
            if (step > 0d) {
                // Determine interval for specific grade
                Integer pos = (int) (log.getFinalGrade() / step);
                if (pos > (resolution - 1)) {
                    pos = resolution.intValue() - 1;
                }

                if (fin.get(log.getUser().getId()) == null) {
                    ArrayList<Double> l = new ArrayList<Double>();
                    for (int i = 0; i < quizzes.size(); i++) {
                        l.add(-1d);
                    }
                    fin.put(log.getUser().getId(), l);
                    fin.get(log.getUser().getId()).set(
                            quizzes.indexOf(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId())),
                            pos.doubleValue());
                } else {
                    fin.get(log.getUser().getId()).set(
                            quizzes.indexOf(Long.valueOf(log.getPrefix() + "" + log.getLearnObjId())),
                            pos.doubleValue());
                }
            }
        }
    }

    BoxPlot[] results = new BoxPlot[fin.keySet().size()];

    ArrayList<Double> c = new ArrayList<Double>();
    c.add(-1d);

    int i = 0;
    Map<Long, Long> idToAlias = StudentHelper.getCourseStudentsRealKeys(courses, gender);
    for (final Entry<Long, ArrayList<Double>> e : fin.entrySet()) {
        e.getValue().removeAll(c);
        final BoxPlot plotty = this.calcBox(e.getValue(), idToAlias.get(e.getKey()));
        results[i] = plotty;
        i++;
    }
    session.close();
    return new ResultListBoxPlot(Arrays.asList(results));
}

From source file:de.lemo.dms.processing.questions.QUserByParameter.java

License:Open Source License

/**
 * Service for retrieval of user-identifiers (Long) that are filtered by the given restrictions.
 * //  w  w w . j a v  a2  s.  c  o m
 * @param courses
 *            (Optional, can be combined with types and objects) Only users are returned, that performed actions in
 *            courses with the given course-identifiers (Long)
 * @param types
 *            (Optional, can be combined with courses and objects) Only users are returned, that performed actions
 *            on the given types of learning-objects.
 * @param objects
 *            (Optional, can be combined with types and courses) Only users are returned, that performed actions
 *            specified learning objects. The list should contain pairs of user-identifiers and object-types
 *            (["1234"],["assignment"] for example).
 * @param roles
 * @param startTime
 *            (Mandatory) Only users are returned, that performed actions after the given time.
 * @param endTime
 *            (Mandatory) Only users are returned, that performed actions before the given time.
 * @return
 */
@POST
public ResultListLongObject compute(@FormParam(MetaParam.COURSE_IDS) final List<Long> courses,
        @FormParam(MetaParam.TYPES) final List<String> types,
        @FormParam(MetaParam.LOG_OBJECT_IDS) final List<String> objects,
        @FormParam(MetaParam.ROLE_IDS) final List<Long> roles,
        @FormParam(MetaParam.START_TIME) final Long startTime,
        @FormParam(MetaParam.END_TIME) final Long endTime) {

    validateTimestamps(startTime, endTime);

    ResultListLongObject userIds = null;

    // Database initialization
    final IDBHandler dbHandler = ServerConfiguration.getInstance().getMiningDbHandler();
    final Session session = dbHandler.getMiningSession();

    // Global list for log items
    List<ILogMining> logs = new ArrayList<ILogMining>();

    // look up if types-restriction is set or the object-list contains at least one pair
    if (!types.isEmpty() || objects.size() > 1) {
        for (ELearningObjectType loType : ELearningObjectType.values()) {

            String typeName = loType.name().toLowerCase();
            if (types.contains(typeName) || objects.contains(typeName)) {
                Criteria criteria = session.createCriteria(loType.getLogMiningType(), "log");
                criteria.add(Restrictions.between("log.timestamp", startTime, endTime));
                if (!courses.isEmpty()) {
                    criteria.add(Restrictions.in("log.course.id", courses));
                }
                List<ILogMining> loadLogMining = loadLogMining(criteria, objects, typeName);
                if (loadLogMining != null) {
                    logs.addAll(loadLogMining);
                }
            }
        }
    } else {
        // If object list and type restriction aren't set, do a more general scan of the database
        final Criteria criteria = session.createCriteria(ILogMining.class, "log")
                .add(Restrictions.between("log.timestamp", startTime, endTime));
        if (!courses.isEmpty()) {
            criteria.add(Restrictions.in("log.course.id", courses));
        }

        @SuppressWarnings("unchecked")
        List<ILogMining> loadLogMining = criteria.list();
        logs = loadLogMining;
    }

    HashMap<Long, Long> usersWithinRoles = null;

    // Doesn't make any sense unless role-identifiers are linked with respective course-identifiers. Standard
    // setting should be 1 course n roles.
    // Working with several courses and roles-per-course will only mess up everything
    if (!roles.isEmpty()) {
        usersWithinRoles = new HashMap<Long, Long>();
        final Criteria criteria = session.createCriteria(CourseUserMining.class, "log")
                .add(Restrictions.in("log.role.id", roles)).add(Restrictions.in("log.course.id", courses));

        @SuppressWarnings("unchecked")
        final List<CourseUserMining> uwr = criteria.list();

        for (int i = 0; i < uwr.size(); i++) {
            if (uwr.get(i).getUser() != null) {
                usersWithinRoles.put(uwr.get(i).getUser().getId(), uwr.get(i).getUser().getId());
            }
        }

    }

    // Create HashMap for user-identifiers to prevent multiple entries for the same user-identifier
    final HashMap<Long, Long> users = new HashMap<Long, Long>();
    for (int i = 0; i < logs.size(); i++) {
        if ((users.get(logs.get(i).getUser().getId()) == null) && usersWithinRoles == null) {
            users.put(logs.get(i).getUser().getId(), logs.get(i).getUser().getId());
        }
        // If there are role restrictions, only user with the specified role get added
        if ((usersWithinRoles != null) && (usersWithinRoles.get(logs.get(i).getUser().getId()) != null)) {
            users.put(logs.get(i).getUser().getId(), logs.get(i).getUser().getId());
        }
    }

    userIds = new ResultListLongObject(new ArrayList<Long>(users.values()));
    session.close();
    return userIds;

}

From source file:de.lemo.dms.processing.questions.QUserLogHistory.java

License:Open Source License

/**
 * Returns all logged events matching the requirements given by the parameters.
 * //from   ww w.  j  a v a2 s.com
 * @param courses
 *            List of course-identifiers
 * @param users
 *            List of user-identifiers
 * @param startTime
 *            LongInteger time stamp
 * @param endTime
 *            LongInteger time stamp
 * @return
 */
@SuppressWarnings("unchecked")
@POST
public ResultListUserLogObject compute(@FormParam(MetaParam.COURSE_IDS) final List<Long> courses,
        @FormParam(MetaParam.USER_IDS) List<Long> users, @FormParam(MetaParam.START_TIME) final Long startTime,
        @FormParam(MetaParam.END_TIME) final Long endTime,
        @FormParam(MetaParam.GENDER) final List<Long> gender) {

    validateTimestamps(startTime, endTime);

    final IDBHandler dbHandler = ServerConfiguration.getInstance().getMiningDbHandler();
    final Session session = dbHandler.getMiningSession();

    Criteria criteria;
    if (users == null || users.size() == 0) {
        users = new ArrayList<Long>(StudentHelper.getCourseStudentsAliasKeys(courses, gender).values());
    } else {
        Map<Long, Long> userMap = StudentHelper.getCourseStudentsAliasKeys(courses, gender);
        List<Long> tmp = new ArrayList<Long>();
        for (int i = 0; i < users.size(); i++) {
            tmp.add(userMap.get(users.get(i)));
        }
        users = tmp;
    }
    criteria = session.createCriteria(ILogMining.class, "log");
    criteria.add(Restrictions.between("log.timestamp", startTime, endTime));
    if (users != null && users.size() > 0)
        criteria.add(Restrictions.in("log.user.id", users));
    if ((courses != null) && (courses.size() > 0)) {
        criteria.add(Restrictions.in("log.course.id", courses));
    }

    final List<ILogMining> logs = criteria.list();

    // HashMap for all user-histories
    final HashMap<Long, List<UserLogObject>> userPaths = new HashMap<Long, List<UserLogObject>>();

    // Iterate through all found log-items for saving log data into UserPathObjects
    for (int i = 0; i < logs.size(); i++) {

        String title = "";
        String type = "";
        ILogMining ilm = null;

        // the log entry has to be cast to its respective class to get its title
        if (logs.get(i).getClass().equals(AssignmentLogMining.class)
                && (((AssignmentLogMining) logs.get(i)).getAssignment() != null)) {
            ilm = logs.get(i);
            type = "assignment";
            title = ((AssignmentLogMining) ilm).getAssignment().getTitle();
        }
        if (logs.get(i).getClass().equals(ForumLogMining.class)
                && (((ForumLogMining) logs.get(i)).getForum() != null)) {
            ilm = logs.get(i);
            type = "forum";
            title = ((ForumLogMining) ilm).getForum().getTitle();
        }

        if (logs.get(i).getClass().equals(QuizLogMining.class)
                && (((QuizLogMining) logs.get(i)).getQuiz() != null)) {
            ilm = logs.get(i);
            type = "quiz";
            title = ((QuizLogMining) ilm).getQuiz().getTitle();
        }
        if (logs.get(i).getClass().equals(QuestionLogMining.class)
                && (((QuestionLogMining) logs.get(i)).getQuestion() != null)) {
            ilm = logs.get(i);
            type = "question";
            title = ((QuestionLogMining) ilm).getQuestion().getTitle();
        }
        if (logs.get(i).getClass().equals(ResourceLogMining.class)
                && (((ResourceLogMining) logs.get(i)).getResource() != null)) {
            ilm = logs.get(i);
            type = "resource";
            title = ((ResourceLogMining) ilm).getResource().getTitle();
        }
        if (logs.get(i).getClass().equals(WikiLogMining.class)
                && (((WikiLogMining) logs.get(i)).getWiki() != null)) {
            ilm = logs.get(i);
            type = "wiki";
            title = ((WikiLogMining) ilm).getWiki().getTitle();
        }

        if (logs.get(i).getClass().equals(ScormLogMining.class)
                && (((ScormLogMining) logs.get(i)).getScorm() != null)) {
            ilm = logs.get(i);
            type = "scorm";
            title = ((ScormLogMining) ilm).getScorm().getTitle();
        }
        if (ilm != null) {
            if (userPaths.get(logs.get(i).getUser().getId()) == null) {
                final ArrayList<UserLogObject> uP = new ArrayList<UserLogObject>();
                // If the user isn't already in the map, create new entry and insert the UserPathObject
                uP.add(new UserLogObject(ilm.getUser().getId(), ilm.getTimestamp(), title, ilm.getId(), type,
                        ilm.getCourse().getId(), ""));
                userPaths.put(logs.get(i).getUser().getId(), uP);
            } else {
                // If the user is known, just add the UserPathObject to the user's history
                userPaths.get(ilm.getUser().getId()).add(new UserLogObject(ilm.getUser().getId(),
                        ilm.getTimestamp(), title, ilm.getId(), type, ilm.getCourse().getId(), ""));
            }
        }
    }

    // List for UserPathObjects
    final List<UserLogObject> l = new ArrayList<UserLogObject>();
    // Insert all entries of all user-histories to the list
    for (final Iterator<List<UserLogObject>> iter = userPaths.values().iterator(); iter.hasNext();) {
        l.addAll(iter.next());
    }
    // Sort the list (first by user and time stamp)
    Collections.sort(l);
    for (int i = 0; i < l.size(); i++) {
        logger.debug(l.get(i).getType());
    }

    final ResultListUserLogObject rlupo = new ResultListUserLogObject(l);

    session.close();
    return rlupo;
}

From source file:de.lemo.dms.processing.questions.QUserPathAnalysis.java

License:Open Source License

/**
 * Returns a list of Nodes and edges, representing the user-navigation
 * matching the requirements given by the parameters.
 * /*from  www . j av a  2 s . c o m*/
 * @see ELearningObjectType
 * @param courses
 *            List of course-identifiers
 * @param users
 *            List of user-identifiers
 * @param types
 *            List of learn object types (see ELearnObjType)
 * @param considerLogouts
 *            If user-paths should be cut when a logout appears this must be
 *            set to "true".
 * @param startTime
 *            LongInteger time stamp
 * @param endTime
 *            LongInteger time stamp
 * @return
 */
@POST
public ResultListUserPathGraph compute(@FormParam(MetaParam.COURSE_IDS) final List<Long> courses,
        @FormParam(MetaParam.USER_IDS) List<Long> users, @FormParam(MetaParam.TYPES) final List<String> types,
        @FormParam(MetaParam.LOGOUT_FLAG) final Boolean considerLogouts,
        @FormParam(MetaParam.START_TIME) final Long startTime,
        @FormParam(MetaParam.END_TIME) final Long endTime,
        @FormParam(MetaParam.GENDER) final List<Long> gender) {

    validateTimestamps(startTime, endTime);

    // DB-initialization
    final IDBHandler dbHandler = ServerConfiguration.getInstance().getMiningDbHandler();
    final Session session = dbHandler.getMiningSession();

    Criteria criteria;
    if (users == null || users.size() == 0) {
        users = new ArrayList<Long>(StudentHelper.getCourseStudentsAliasKeys(courses, gender).values());
    } else {
        Map<Long, Long> userMap = StudentHelper.getCourseStudentsAliasKeys(courses, gender);
        List<Long> tmp = new ArrayList<Long>();
        for (int i = 0; i < users.size(); i++) {
            tmp.add(userMap.get(users.get(i)));
        }
        users = tmp;
    }

    // Create criteria for log-file-search
    criteria = session.createCriteria(ILogMining.class, "log");

    criteria.add(Restrictions.between("log.timestamp", startTime, endTime));
    criteria.addOrder(Order.asc("log.timestamp"));

    if (!courses.isEmpty()) {
        criteria.add(Restrictions.in("log.course.id", courses));
    }

    if (!users.isEmpty()) {
        criteria.add(Restrictions.in("log.user.id", users));
    }

    @SuppressWarnings("unchecked")
    final List<ILogMining> list = criteria.list();

    Collections.sort(list);

    this.logger.debug("Total matched entries: " + list.size());

    // Map for UserPathObjects
    final LinkedHashMap<String, UserPathObject> pathObjects = Maps.newLinkedHashMap();

    // Map for user histories
    final HashMap<Long, List<ILogMining>> userHis = Maps.newHashMap();

    int skippedUsers = 0;
    // Generate user histories
    for (final ILogMining log : list) {
        if (log.getUser() == null) {
            skippedUsers++;
            continue;
        }
        boolean typeOk = true;
        if (!types.isEmpty()) {
            typeOk = false;
            for (final String type : types) {
                /*
                 * XXX why is this checked for every log object and not a
                 * criteria restriction?
                 */
                // Check if ILog-object has acceptable learningObjectType
                if (ELearningObjectType.fromLogMiningType(log).toString().toUpperCase().equals(type)) {
                    typeOk = true;
                    break;
                }
            }
        }

        if (typeOk) {
            if (userHis.get(log.getUser().getId()) == null) {
                // If user is new create a new entry in the hash map and add
                // log item
                userHis.put(log.getUser().getId(), new ArrayList<ILogMining>());
                userHis.get(log.getUser().getId()).add(log);
            } else {
                userHis.get(log.getUser().getId()).add(log);
            }
        }
    }

    this.logger.debug("Skipped entries with missing user id: " + skippedUsers);

    int skippedLogs = 0;
    // Generate paths from user histories
    for (final List<ILogMining> l : userHis.values()) {
        String predNode = null;
        for (int i = 0; i < l.size(); i++) {
            if ((l.get(i) != null) && (l.get(i).getUser() != null)) {
                final ILogMining current = l.get(i);

                final Long learnObjId = current.getLearnObjId();
                if (learnObjId == null) {
                    skippedLogs++;
                    continue;
                }
                final String learnObjType = ELearningObjectType.fromLogMiningType(current).toString();
                final String type = current.getClass().toString().substring(
                        current.getClass().toString().lastIndexOf(".") + 1,
                        current.getClass().toString().lastIndexOf("Log"));
                final String cId = learnObjId + "-" + learnObjType;
                // Determines whether it's a new path (no predecessor for
                // current node) or not

                UserPathObject knownPath;
                if (predNode != null) {
                    String cIdPos = null;
                    if ((knownPath = pathObjects.get(cId)) == null) {
                        // If the node is new create entry in hash map
                        cIdPos = String.valueOf(pathObjects.size());
                        pathObjects.put(cId, new UserPathObject(cIdPos, current.getTitle(), 1L, type,
                                Double.valueOf(current.getDuration()), 1L, 0L, 0L, 0L));
                    } else {
                        // If the node is already known, increase weight
                        pathObjects.get(cId).increaseWeight(Double.valueOf(current.getDuration()));
                        cIdPos = knownPath.getId();
                    }

                    // Increment or create predecessor edge
                    pathObjects.get(predNode).addEdgeOrIncrement(cIdPos);
                } else if (pathObjects.get(cId) == null) {
                    final String cIdPos = String.valueOf(pathObjects.size());
                    pathObjects.put(cId, new UserPathObject(cIdPos, current.getTitle(), 1L, type,
                            Double.valueOf(current.getDuration()), 1L, 0L, 0L, 0L));
                } else {
                    pathObjects.get(cId).increaseWeight(Double.valueOf(current.getDuration()));
                }

                if (considerLogouts && (current.getDuration() == -1L)) {
                    predNode = null;
                } else {
                    predNode = cId;
                }
            }
        }
    }
    this.logger.debug("Skipped entries with missing learn object id: " + skippedLogs);

    final ArrayList<UserPathNode> nodes = Lists.newArrayList();
    final ArrayList<UserPathLink> links = Lists.newArrayList();

    for (final UserPathObject pathEntry : pathObjects.values()) {

        final UserPathObject path = pathEntry;
        path.setPathId(pathEntry.getPathId());
        nodes.add(new UserPathNode(path));
        final String sourcePos = path.getId();

        for (final Entry<String, Integer> linkEntry : pathEntry.getEdges().entrySet()) {
            final UserPathLink link = new UserPathLink();
            link.setSource(sourcePos);
            link.setPathId(path.getPathId());
            link.setTarget(linkEntry.getKey());
            link.setValue(String.valueOf(linkEntry.getValue()));
            if (link.getSource() != link.getTarget()) {
                links.add(link);
            }
        }
    }
    session.close();
    return new ResultListUserPathGraph(nodes, links);
}

From source file:debop4k.data.orm.hibernate.CriteriaEx.java

License:Apache License

/**
 * ? ? lo, hi ?? ?  ?/*ww  w . j  a va2  s  .c o m*/
 *
 * @param property  ? 
 * @param lo         
 * @param hi        ? 
 * @param includeLo   ? 
 * @param includeHi ?  ? 
 * @return the is between criterion
 */
public static Criterion between(String property, Object lo, Object hi, boolean includeLo, boolean includeHi) {
    shouldNotBeEmpty(property, "property");
    if (lo == null && hi == null)
        throw new IllegalArgumentException("?  ? null .");

    if (lo != null && hi != null)
        return Restrictions.between(property, lo, hi);

    Conjunction result = conjunction();
    if (lo != null)
        result.add(great(property, lo, includeLo));

    if (hi != null)
        result.add(less(property, hi, includeHi));

    return result;
}

From source file:dk.teachus.backend.dao.hibernate.HibernateBookingDAO.java

License:Apache License

@SuppressWarnings("unchecked")
@Transactional(readOnly = true)//from ww  w  . j  a va  2s.c o  m
public List<PupilBooking> getPaidBookings(Teacher teacher, DateMidnight startDate, DateMidnight endDate) {
    DetachedCriteria c = DetachedCriteria.forClass(PupilBookingImpl.class);

    c.createCriteria("period").add(Restrictions.eq("status", Status.FINAL));
    c.createCriteria("pupil").add(Restrictions.eq("teacher", teacher)).add(Restrictions.eq("active", true))
            .createCriteria("teacher").add(Restrictions.eq("active", true));
    c.add(Restrictions.eq("paid", true));
    c.add(Restrictions.eq("active", true));

    if (startDate != null && endDate != null) {
        c.add(Restrictions.between("date", startDate.toDateTime(), endDate.toDateTime()));
    } else if (startDate != null) {
        c.add(Restrictions.gt("date", startDate.toDateTime()));
    } else if (endDate != null) {
        c.add(Restrictions.lt("date", endDate.toDateTime()));
    }

    c.addOrder(Order.asc("date"));

    return getHibernateTemplate().findByCriteria(c);
}

From source file:dk.teachus.backend.dao.hibernate.HibernateBookingDAO.java

License:Apache License

@SuppressWarnings("unchecked")
@Transactional(readOnly = true)//from  w  w  w .j  a v  a 2  s.co m
public List<PupilBooking> getUnPaidBookings(Teacher teacher, DateMidnight startDate, DateMidnight endDate) {
    DetachedCriteria c = DetachedCriteria.forClass(PupilBookingImpl.class);

    c.createCriteria("period").add(Restrictions.eq("status", Status.FINAL));
    c.createCriteria("pupil").add(Restrictions.eq("teacher", teacher)).add(Restrictions.eq("active", true))
            .createCriteria("teacher").add(Restrictions.eq("active", true));
    c.add(Restrictions.eq("paid", false));
    c.add(Restrictions.eq("active", true));

    if (startDate != null && endDate != null) {
        c.add(Restrictions.between("date", startDate.toDateTime(), endDate.toDateTime()));
    } else if (startDate != null) {
        c.add(Restrictions.gt("date", startDate.toDateTime()));
    } else if (endDate != null) {
        c.add(Restrictions.lt("date", endDate.toDateTime()));
    }

    c.addOrder(Order.asc("date"));

    return getHibernateTemplate().findByCriteria(c);
}