/** {@inheritDoc} */
public boolean canReadNoteItem(Assignment a, String context) {
if (a != null) {
AssignmentNoteItem note = getNoteItem(a.getId());
if (note != null) {
User u = m_userDirectoryService.getCurrentUser();
String noteCreatorId = note.getCreatorId();
if (noteCreatorId.equals(u.getId())) {
return true;
} else if (m_assignmentService.allowGradeSubmission(a.getReference())) {
// check whether the instructor type can view the note
int share = note.getShareWith();
if (share == AssignmentConstants.NOTE_READ_BY_OTHER
|| share == AssignmentConstants.NOTE_READ_AND_WRITE_BY_OTHER) {
return true;
}
}
}
} else {
if (m_assignmentService.allowAddAssignment(context)) {
return true;
}
}
return false;
}
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();
}
}
/** {@inheritDoc} */
public boolean canEditNoteItem(Assignment a) {
String userId = "";
User u = m_userDirectoryService.getCurrentUser();
if (u != null) {
userId = u.getId();
}
if (a != null) {
AssignmentNoteItem note = getNoteItem(a.getId());
if (note != null) {
if (note.getCreatorId().equals(userId)) {
// being creator can edit
return true;
} else if (note.getShareWith() == AssignmentConstants.NOTE_READ_AND_WRITE_BY_OTHER
&& m_assignmentService.allowGradeSubmission(a.getReference())) {
return true;
}
} else {
return true;
}
} else {
return true;
}
return false;
}
/** {@inheritDoc} */
public boolean canViewModelAnswer(Assignment a, AssignmentSubmission s) {
if (a != null) {
AssignmentModelAnswerItem m = getModelAnswer(a.getId());
if (m != null) {
if (m_assignmentService.allowGradeSubmission(a.getReference())) {
// model answer is viewable to all graders
return true;
} else {
int show = m.getShowTo();
if (show == AssignmentConstants.MODEL_ANSWER_SHOW_TO_STUDENT_BEFORE_STARTS) {
return true;
} else if (show == AssignmentConstants.MODEL_ANSWER_SHOW_TO_STUDENT_AFTER_SUBMIT
&& s != null
&& s.getSubmitted()) {
return true;
} else if (show == AssignmentConstants.MODEL_ANSWER_SHOW_TO_STUDENT_AFTER_GRADE_RETURN
&& s != null
&& s.getGradeReleased()) {
return true;
} else if (show == AssignmentConstants.MODEL_ANSWER_SHOW_TO_STUDENT_AFTER_ACCEPT_UTIL
&& (a.getCloseTime().before(TimeService.newTime()))) {
return true;
}
}
}
}
return false;
}
/** 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);
}
}
public boolean updateScore(String submissionId) {
boolean saved = false;
SecurityAdvisor sa =
new SecurityAdvisor() {
public SecurityAdvice isAllowed(String userId, String function, String reference) {
if (AssignmentService.SECURE_GRADE_ASSIGNMENT_SUBMISSION.equals(function)
|| AssignmentService.SECURE_UPDATE_ASSIGNMENT.equals(function)
|| AssignmentService.SECURE_ACCESS_ASSIGNMENT.equals(function)
|| AssignmentService.SECURE_ACCESS_ASSIGNMENT_SUBMISSION.equals(function)) {
return SecurityAdvice.ALLOWED;
} else {
return SecurityAdvice.PASS;
}
}
};
try {
securityService.pushAdvisor(sa);
// first check that submission exists and that it can be graded/override score
AssignmentSubmission submission = assignmentService.getSubmission(submissionId);
// only override grades that have never been graded or was last graded by this service
// this prevents this service from overriding instructor set grades, which take precedent.
if (submission != null
&& (submission.getGraded() == false
|| submission.getGradedBy() == null
|| "".equals(submission.getGradedBy().trim())
|| AssignmentPeerAssessmentService.class
.getName()
.equals(submission.getGradedBy().trim()))) {
List<PeerAssessmentItem> items =
getPeerAssessmentItems(
submissionId, submission.getAssignment().getContent().getFactor());
if (items != null) {
// scores are stored w/o decimal points, so a score of 3.4 is stored as 34 in the DB
// add all the scores together and divide it by the number of scores added. Then round.
Integer totalScore = 0;
int denominator = 0;
for (PeerAssessmentItem item : items) {
if (!item.isRemoved() && item.getScore() != null) {
totalScore += item.getScore();
denominator++;
}
}
if (denominator > 0) {
totalScore = Math.round(totalScore / denominator);
} else {
totalScore = null;
}
String totleScoreStr = null;
if (totalScore != null) {
totleScoreStr = totalScore.toString();
}
boolean changed = false;
if ((totleScoreStr == null || "".equals(totleScoreStr))
&& (submission.getGrade() == null || "".equals(submission.getGrade()))) {
// scores are both null, nothing changed
} else if ((totleScoreStr != null && !"".equals(totleScoreStr))
&& (submission.getGrade() == null || "".equals(submission.getGrade()))) {
// one score changed, update
changed = true;
} else if ((totleScoreStr == null || "".equals(totleScoreStr))
&& (submission.getGrade() != null && !"".equals(submission.getGrade()))) {
// one score changed, update
changed = true;
} else if (!totleScoreStr.equals(submission.getGrade())) {
changed = true;
}
if (changed) {
AssignmentSubmissionEdit edit = assignmentService.editSubmission(submissionId);
edit.setGrade(totleScoreStr);
edit.setGraded(true);
edit.setGradedBy(AssignmentPeerAssessmentService.class.getName());
edit.setGradeReleased(false);
assignmentService.commitEdit(edit);
saved = true;
}
}
}
} catch (IdUnusedException e) {
log.error(e.getMessage(), e);
} catch (InUseException e) {
log.error(e.getMessage(), e);
} catch (PermissionException e) {
log.error(e.getMessage(), e);
} finally {
// remove advisor
if (sa != null) {
securityService.popAdvisor(sa);
}
}
return saved;
}
