public void schedulePeerReview(String assignmentId) {
   // first remove any previously scheduled reviews:
   removeScheduledPeerReview(assignmentId);
   // now schedule a time for the review to be setup
   Assignment assignment;
   try {
     assignment = assignmentService.getAssignment(assignmentId);
     if (!assignment.getDraft() && assignment.getAllowPeerAssessment()) {
       Time assignmentCloseTime = assignment.getCloseTime();
       Time openTime = null;
       if (assignmentCloseTime != null) {
         openTime = timeService.newTime(assignmentCloseTime.getTime());
       }
       // Schedule the new notification
       if (openTime != null) {
         scheduledInvocationManager.createDelayedInvocation(
             openTime,
             "org.sakaiproject.assignment.api.AssignmentPeerAssessmentService",
             assignmentId);
       }
     }
   } catch (IdUnusedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   } catch (PermissionException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }
  /** Method called by the scheduledInvocationManager */
  public void execute(String opaqueContext) {
    try {
      // for group assignments, we need to have a user ID, otherwise, an exception is thrown:
      sessionManager.getCurrentSession().setUserEid("admin");
      sessionManager.getCurrentSession().setUserId("admin");
      Assignment assignment = assignmentService.getAssignment(opaqueContext);
      if (assignment.getAllowPeerAssessment() && !assignment.getDraft()) {
        int numOfReviews = assignment.getPeerAssessmentNumReviews();
        List<AssignmentSubmission> submissions =
            (List<AssignmentSubmission>) assignmentService.getSubmissions(assignment);
        // keep a map of submission ids to look up possible existing peer assessments
        Map<String, AssignmentSubmission> submissionIdMap =
            new HashMap<String, AssignmentSubmission>();
        // keep track of who has been assigned an assessment
        Map<String, Map<String, PeerAssessmentItem>> assignedAssessmentsMap =
            new HashMap<String, Map<String, PeerAssessmentItem>>();
        // keep track of how many assessor's each student has
        Map<String, Integer> studentAssessorsMap = new HashMap<String, Integer>();
        List<User> submitterUsersList =
            (List<User>) assignmentService.allowAddSubmissionUsers(assignment.getReference());
        List<String> submitterIdsList = new ArrayList<String>();
        if (submitterUsersList != null) {
          for (User u : submitterUsersList) {
            submitterIdsList.add(u.getId());
          }
        }
        // loop through the assignment submissions and setup the maps and lists
        for (AssignmentSubmission s : submissions) {
          if (s.getTimeSubmitted() != null
              // check if the submission is submitted, if not, see if there is any submission data
              // to review (i.e. draft was auto submitted)
              && (s.getSubmitted()
                  || ((s.getSubmittedText() != null && !"".equals(s.getSubmittedText().trim())
                      || (s.getSubmittedAttachments() != null
                          && s.getSubmittedAttachments().size() > 0))))
              && submitterIdsList.contains(s.getSubmitterId())
              && !"admin".equals(s.getSubmitterId())) {
            // only deal with users in the submitter's list
            submissionIdMap.put(s.getId(), s);
            assignedAssessmentsMap.put(
                s.getSubmitterId(), new HashMap<String, PeerAssessmentItem>());
            studentAssessorsMap.put(s.getSubmitterId(), 0);
          }
        }
        // this could be an update to an existing assessment... just make sure to grab any existing
        // review items first
        List<PeerAssessmentItem> existingItems =
            getPeerAssessmentItems(submissionIdMap.keySet(), assignment.getContent().getFactor());
        List<PeerAssessmentItem> removeItems = new ArrayList<PeerAssessmentItem>();
        // remove all empty items to start from scratch:
        for (Iterator iterator = existingItems.iterator(); iterator.hasNext(); ) {
          PeerAssessmentItem peerAssessmentItem = (PeerAssessmentItem) iterator.next();
          if (peerAssessmentItem.getScore() == null
              && (peerAssessmentItem.getComment() == null
                  || "".equals(peerAssessmentItem.getComment().trim()))) {
            removeItems.add(peerAssessmentItem);
            iterator.remove();
          }
        }
        if (removeItems.size() > 0) {
          getHibernateTemplate().deleteAll(removeItems);
        }
        // loop through the items and update the map values:
        for (PeerAssessmentItem p : existingItems) {
          if (submissionIdMap.containsKey(p.getSubmissionId())) {
            // first, add this assessment to the AssignedAssessmentsMap
            AssignmentSubmission s = submissionIdMap.get(p.getSubmissionId());
            // Next, increment the count for studentAssessorsMap
            Integer count = studentAssessorsMap.get(s.getSubmitterId());
            if (count == null) {
              // probably not possible, just check
              count = 0;
            }
            // check if the count is less than num of reviews before added another one,
            // otherwise, we need to delete this one (if it's empty)
            if (count < numOfReviews || p.getScore() != null || p.getComment() != null) {
              count++;
              studentAssessorsMap.put(s.getSubmitterId(), count);
              Map<String, PeerAssessmentItem> peerAssessments =
                  assignedAssessmentsMap.get(p.getAssessorUserId());
              if (peerAssessments == null) {
                // probably not possible, but just check
                peerAssessments = new HashMap<String, PeerAssessmentItem>();
              }
              peerAssessments.put(p.getSubmissionId(), p);
              assignedAssessmentsMap.put(p.getAssessorUserId(), peerAssessments);
            } else {
              // this shoudln't happen since the code above removes all empty assessments, but just
              // in case:
              getHibernateTemplate().delete(p);
            }
          } else {
            // this isn't realy possible since we looked up the peer assessments by submission id
            log.error(
                "AssignmentPeerAssessmentServiceImpl: found a peer assessment with an invalid session id: "
                    + p.getSubmissionId());
          }
        }

        // ok now that we have any existing assigned reviews accounted for, let's make sure that the
        // number of reviews is setup properly,
        // if not, add some
        // let's get a random order of submission IDs so we can have a random assigning algorithm
        List<String> randomSubmissionIds = new ArrayList<String>(submissionIdMap.keySet());
        Collections.shuffle(randomSubmissionIds);
        List<PeerAssessmentItem> newItems = new ArrayList<PeerAssessmentItem>();
        int i = 0;
        for (String submissionId : randomSubmissionIds) {
          AssignmentSubmission s = submissionIdMap.get(submissionId);
          // first find out how many existing items exist for this user:
          Integer assignedCount = studentAssessorsMap.get(s.getSubmitterId());
          // by creating a tailing list (snake style), we eliminate the issue where you can be stuck
          // with
          // a submission and the same submission user left, making for uneven distributions of
          // submission reviews
          List<String> snakeSubmissionList =
              new ArrayList<String>(randomSubmissionIds.subList(i, randomSubmissionIds.size()));
          if (i > 0) {
            snakeSubmissionList.addAll(new ArrayList<String>(randomSubmissionIds.subList(0, i)));
          }
          while (assignedCount < numOfReviews) {
            // we need to add more reviewers for this user's submission
            String lowestAssignedAssessor =
                findLowestAssignedAssessor(
                    assignedAssessmentsMap,
                    s.getSubmitterId(),
                    submissionId,
                    snakeSubmissionList,
                    submissionIdMap);
            if (lowestAssignedAssessor != null) {
              Map<String, PeerAssessmentItem> assessorsAssessmentMap =
                  assignedAssessmentsMap.get(lowestAssignedAssessor);
              if (assessorsAssessmentMap == null) {
                assessorsAssessmentMap = new HashMap<String, PeerAssessmentItem>();
              }
              PeerAssessmentItem newItem = new PeerAssessmentItem();
              newItem.setAssessorUserId(lowestAssignedAssessor);
              newItem.setSubmissionId(submissionId);
              newItem.setAssignmentId(assignment.getId());
              newItems.add(newItem);
              assessorsAssessmentMap.put(submissionId, newItem);
              assignedAssessmentsMap.put(lowestAssignedAssessor, assessorsAssessmentMap);
              // update this submission user's count:
              assignedCount++;
              studentAssessorsMap.put(submissionId, assignedCount);
            } else {
              break;
            }
          }
          i++;
        }
        if (newItems.size() > 0) {
          getHibernateTemplate().saveOrUpdateAll(newItems);
        }
      }
    } catch (IdUnusedException e) {
      log.error(e.getMessage(), e);
    } catch (PermissionException e) {
      log.error(e.getMessage(), e);
    } finally {
      sessionManager.getCurrentSession().setUserEid(null);
      sessionManager.getCurrentSession().setUserId(null);
    }
  }
  @WebMethod
  @Path("/getAssignmentsForContext")
  @Produces("text/plain")
  @GET
  public String getAssignmentsForContext(
      @WebParam(name = "sessionid", partName = "sessionid") @QueryParam("sessionid")
          String sessionid,
      @WebParam(name = "context", partName = "context") @QueryParam("context") String context) {

    try {
      // establish the session
      Session s = establishSession(sessionid);

      // ok will this give me a list of assignments for the course
      LOG.info("assignment list requested for " + context);

      Iterator assignments = assignmentService.getAssignmentsForContext(context);
      Document dom = Xml.createDocument();
      Node all = dom.createElement("assignments");
      dom.appendChild(all);

      while (assignments.hasNext()) {
        Assignment thisA = (Assignment) assignments.next();
        LOG.debug("got " + thisA.getTitle());
        if (!thisA.getDraft()) {
          AssignmentContent asCont = thisA.getContent();

          LOG.debug("about to start building xml doc");
          Element uElement = dom.createElement("assignment");
          uElement.setAttribute("id", thisA.getId());
          uElement.setAttribute("title", thisA.getTitle());
          LOG.debug("added title and id");
          if (asCont != null) {
            Integer temp = new Integer(asCont.getTypeOfGrade());
            String gType = temp.toString();
            uElement.setAttribute("gradeType", gType);
          }

          /* these need to be converted to strings
           */

          LOG.debug("About to get dates");

          Time dueTime = thisA.getDueTime();
          Time openTime = thisA.getOpenTime();
          Time closeTime = thisA.getCloseTime();
          LOG.debug("got dates");
          DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z");

          if (openTime != null) {
            LOG.debug("open time is " + openTime.toString());
            uElement.setAttribute("openTime", format.format(new Date(openTime.getTime())));
          }
          if (closeTime != null) {
            LOG.debug("close time is " + closeTime.toString());
            uElement.setAttribute("closeTime", format.format(new Date(closeTime.getTime())));
          }

          if (dueTime != null) {
            LOG.debug("due time is " + dueTime.toString());
            uElement.setAttribute("dueTime", format.format(new Date(dueTime.getTime())));
          }

          LOG.debug("apending element to parent");
          all.appendChild(uElement);
        } else {
          LOG.debug("this is a draft assignment");
        }
      }
      String retVal = Xml.writeDocumentToString(dom);
      return retVal;
    } catch (Exception e) {
      LOG.error(
          "WS getAssignmentsForContext(): " + e.getClass().getName() + " : " + e.getMessage());
    }

    return "<assignments/ >";
  }