@WebMethod
@Path("/getSubmissionsForAssignment")
@Produces("text/plain")
@GET
public String getSubmissionsForAssignment(
@WebParam(name = "sessionId", partName = "sessionId") @QueryParam("sessionId")
String sessionId,
@WebParam(name = "assignmentId", partName = "assignmentId") @QueryParam("assignmentId")
String assignmentId) {
try {
Session s = establishSession(sessionId);
Assignment assign = assignmentService.getAssignment(assignmentId);
List subs = assignmentService.getSubmissions(assign);
// build the xml
LOG.debug("about to start building xml doc");
Document dom = Xml.createDocument();
Node all = dom.createElement("submissions");
dom.appendChild(all);
for (int i = 0; i < subs.size(); i++) {
AssignmentSubmission thisSub = (AssignmentSubmission) subs.get(i);
LOG.debug("got submission" + thisSub);
Element uElement = dom.createElement("submission");
uElement.setAttribute("feedback-comment", thisSub.getFeedbackComment());
uElement.setAttribute("feedback-text", thisSub.getFeedbackText());
uElement.setAttribute("grade", thisSub.getGrade());
uElement.setAttribute("status", thisSub.getStatus());
uElement.setAttribute("submitted-text", thisSub.getSubmittedText());
List submitters = thisSub.getSubmitterIds();
for (int q = 0; q < submitters.size(); q++) {
uElement.setAttribute("submitter-id", (String) submitters.get(q));
}
List submissions = thisSub.getSubmittedAttachments();
// Element attachments = dom.createElement("attachment");
for (int q = 0; q < submissions.size(); q++) {
// Element attachments = dom.createElement("attachment");
Reference ref = (Reference) submissions.get(q);
Entity ent = ref.getEntity();
uElement.setAttribute("attachment-url", ent.getUrl());
// all.appendChild();
}
all.appendChild(uElement);
}
String retVal = Xml.writeDocumentToString(dom);
return retVal;
} catch (Exception e) {
LOG.error(
"WS getSubmissionsForAssignment(): " + e.getClass().getName() + " : " + e.getMessage());
}
return "<submissions />";
}
/** 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);
}
}
