/** {@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;
}
@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 />";
}
private String findLowestAssignedAssessor(
Map<String, Map<String, PeerAssessmentItem>> peerAssessments,
String assesseeId,
String assesseeSubmissionId,
List<String> snakeSubmissionList,
Map<String, AssignmentSubmission>
submissionIdMap) { // find the lowest count of assigned submissions
String lowestAssignedAssessor = null;
Integer lowestAssignedAssessorCount = null;
for (String sId : snakeSubmissionList) {
AssignmentSubmission s = submissionIdMap.get(sId);
// do not include assesseeId (aka the user being assessed)
if (!assesseeId.equals(s.getSubmitterId())
&& (lowestAssignedAssessorCount == null
|| peerAssessments.get(s.getSubmitterId()).keySet().size()
< lowestAssignedAssessorCount)) {
// check if this user already has a peer assessment for this assessee
boolean found = false;
for (PeerAssessmentItem p : peerAssessments.get(s.getSubmitterId()).values()) {
if (p.getSubmissionId().equals(assesseeSubmissionId)) {
found = true;
break;
}
}
if (!found) {
lowestAssignedAssessorCount = peerAssessments.get(s.getSubmitterId()).keySet().size();
lowestAssignedAssessor = s.getSubmitterId();
}
}
}
return lowestAssignedAssessor;
}
/** 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;
}
/**
* @param assignmentRef
* @param associateGradebookAssignment
* @param addUpdateRemoveAssignment
* @param newAssignment_title
* @param newAssignment_maxPoints
* @param newAssignment_dueTime
* @param submissionRef
* @param updateRemoveSubmission
* @param context
*/
protected void integrateGradebook(
String assignmentRef,
String associateGradebookAssignment,
String addUpdateRemoveAssignment,
String newAssignment_title,
int newAssignment_maxPoints,
Time newAssignment_dueTime,
String submissionRef,
String updateRemoveSubmission,
String context) {
// add or remove external grades to gradebook
// a. if Gradebook does not exists, do nothing, 'cos setting should have been hidden
// b. if Gradebook exists, just call addExternal and removeExternal and swallow any exception.
// The
// exception are indication that the assessment is already in the Gradebook or there is
// nothing
// to remove.
String gradebookUid = context;
boolean gradebookExists = isGradebookDefined(context);
String assignmentToolTitle = "Assignments";
if (gradebookExists) {
boolean isExternalAssignmentDefined =
gradebookExternalAssessmentService.isExternalAssignmentDefined(
gradebookUid, assignmentRef);
boolean isExternalAssociateAssignmentDefined =
gradebookExternalAssessmentService.isExternalAssignmentDefined(
gradebookUid, associateGradebookAssignment);
boolean isAssignmentDefined =
gradebookService.isAssignmentDefined(gradebookUid, associateGradebookAssignment);
if (addUpdateRemoveAssignment != null) {
if (addUpdateRemoveAssignment.equals("add")
|| (addUpdateRemoveAssignment.equals("update")
&& !gradebookService.isAssignmentDefined(gradebookUid, newAssignment_title))) {
// add assignment into gradebook
try {
// add assignment to gradebook
gradebookExternalAssessmentService.addExternalAssessment(
gradebookUid,
assignmentRef,
null,
newAssignment_title,
newAssignment_maxPoints / 10,
new Date(newAssignment_dueTime.getTime()),
"Assignment");
} catch (AssignmentHasIllegalPointsException e) {
// addAlert(state, rb.getString("addtogradebook.illegalPoints"));
} catch (ConflictingAssignmentNameException e) {
// try to modify assignment title, make sure there is no such assignment in the
// gradebook, and insert again
boolean trying = true;
int attempts = 1;
String titleBase = newAssignment_title;
while (trying
&& attempts < MAXIMUM_ATTEMPTS_FOR_UNIQUENESS) // see end of loop for condition that
// enforces attempts <= limit)
{
String newTitle = titleBase + "-" + attempts;
if (!gradebookService.isAssignmentDefined(gradebookUid, newTitle)) {
try {
// add assignment to gradebook
gradebookExternalAssessmentService.addExternalAssessment(
gradebookUid,
assignmentRef,
null,
newTitle,
newAssignment_maxPoints / 10,
new Date(newAssignment_dueTime.getTime()),
"Assignment");
trying = false;
} catch (Exception ee) {
// try again, ignore the exception
}
}
if (trying) {
attempts++;
if (attempts >= MAXIMUM_ATTEMPTS_FOR_UNIQUENESS) {
// add alert prompting for change assignment title
// addAlert(state, rb.getString("addtogradebook.nonUniqueTitle"));
}
}
}
} catch (ConflictingExternalIdException e) {
// ignore
} catch (GradebookNotFoundException e) {
// ignore
} catch (Exception e) {
// ignore
}
} // (addUpdateRemoveAssignment.equals("add") || (
// addUpdateRemoveAssignment.equals("update") && !g.isAssignmentDefined(gradebookUid,
// newAssignment_title)))
} // addUpdateRemoveAssignment != null
if (updateRemoveSubmission != null) {
try {
Assignment a = assignmentService.getAssignment(assignmentRef);
if (updateRemoveSubmission.equals("update")
&& a.getProperties().getProperty(NEW_ASSIGNMENT_ADD_TO_GRADEBOOK) != null
&& !a.getProperties()
.getProperty(NEW_ASSIGNMENT_ADD_TO_GRADEBOOK)
.equals(AssignmentService.GRADEBOOK_INTEGRATION_NO)
&& a.getContent().getTypeOfGrade() == Assignment.SCORE_GRADE_TYPE) {
if (submissionRef == null) {
// bulk add all grades for assignment into gradebook
Iterator submissions = assignmentService.getSubmissions(a).iterator();
Map m = new HashMap();
// any score to copy over? get all the assessmentGradingData and copy over
while (submissions.hasNext()) {
AssignmentSubmission aSubmission = (AssignmentSubmission) submissions.next();
if (aSubmission.getGradeReleased()) {
User[] submitters = aSubmission.getSubmitters();
String submitterId = submitters[0].getId();
String gradeString = StringUtils.trimToNull(aSubmission.getGrade(false));
Double grade =
gradeString != null ? Double.valueOf(displayGrade(gradeString)) : null;
m.put(submitterId, grade);
}
}
// need to update only when there is at least one submission
if (m.size() > 0) {
if (associateGradebookAssignment != null) {
if (isExternalAssociateAssignmentDefined) {
// the associated assignment is externally maintained
gradebookExternalAssessmentService.updateExternalAssessmentScores(
gradebookUid, associateGradebookAssignment, m);
} else if (isAssignmentDefined) {
// the associated assignment is internal one, update records one by one
submissions = assignmentService.getSubmissions(a).iterator();
while (submissions.hasNext()) {
AssignmentSubmission aSubmission = (AssignmentSubmission) submissions.next();
User[] submitters = aSubmission.getSubmitters();
String submitterId = submitters[0].getId();
String gradeString = StringUtils.trimToNull(aSubmission.getGrade(false));
String grade =
(gradeString != null && aSubmission.getGradeReleased())
? displayGrade(gradeString)
: null;
gradebookService.setAssignmentScoreString(
gradebookUid,
associateGradebookAssignment,
submitterId,
grade,
assignmentToolTitle);
}
}
} else if (isExternalAssignmentDefined) {
gradebookExternalAssessmentService.updateExternalAssessmentScores(
gradebookUid, assignmentRef, m);
}
}
} else {
try {
// only update one submission
AssignmentSubmission aSubmission =
(AssignmentSubmission) assignmentService.getSubmission(submissionRef);
User[] submitters = aSubmission.getSubmitters();
String gradeString = StringUtils.trimToNull(aSubmission.getGrade(false));
if (associateGradebookAssignment != null) {
if (gradebookExternalAssessmentService.isExternalAssignmentDefined(
gradebookUid, associateGradebookAssignment)) {
// the associated assignment is externally maintained
gradebookExternalAssessmentService.updateExternalAssessmentScore(
gradebookUid,
associateGradebookAssignment,
submitters[0].getId(),
(gradeString != null && aSubmission.getGradeReleased())
? displayGrade(gradeString)
: null);
} else if (gradebookService.isAssignmentDefined(
gradebookUid, associateGradebookAssignment)) {
// the associated assignment is internal one, update records
gradebookService.setAssignmentScoreString(
gradebookUid,
associateGradebookAssignment,
submitters[0].getId(),
(gradeString != null && aSubmission.getGradeReleased())
? displayGrade(gradeString)
: null,
assignmentToolTitle);
}
} else {
gradebookExternalAssessmentService.updateExternalAssessmentScore(
gradebookUid,
assignmentRef,
submitters[0].getId(),
(gradeString != null && aSubmission.getGradeReleased())
? displayGrade(gradeString)
: null);
}
} catch (Exception e) {
LOG.warn("Cannot find submission " + submissionRef + ": " + e.getMessage());
}
} // submissionref != null
} else if (updateRemoveSubmission.equals("remove")) {
if (submissionRef == null) {
// remove all submission grades (when changing the associated entry in Gradebook)
Iterator submissions = assignmentService.getSubmissions(a).iterator();
// any score to copy over? get all the assessmentGradingData and copy over
while (submissions.hasNext()) {
AssignmentSubmission aSubmission = (AssignmentSubmission) submissions.next();
User[] submitters = aSubmission.getSubmitters();
if (isExternalAssociateAssignmentDefined) {
// if the old associated assignment is an external maintained one
gradebookExternalAssessmentService.updateExternalAssessmentScore(
gradebookUid, associateGradebookAssignment, submitters[0].getId(), null);
} else if (isAssignmentDefined) {
gradebookService.setAssignmentScoreString(
gradebookUid,
associateGradebookAssignment,
submitters[0].getId(),
null,
assignmentToolTitle);
}
}
} else {
// remove only one submission grade
try {
AssignmentSubmission aSubmission =
(AssignmentSubmission) assignmentService.getSubmission(submissionRef);
User[] submitters = aSubmission.getSubmitters();
gradebookExternalAssessmentService.updateExternalAssessmentScore(
gradebookUid, assignmentRef, submitters[0].getId(), null);
} catch (Exception e) {
LOG.warn("Cannot find submission " + submissionRef + ": " + e.getMessage());
}
}
}
} catch (Exception e) {
LOG.warn("Cannot find assignment: " + assignmentRef + ": " + e.getMessage());
}
} // updateRemoveSubmission != null
} // if gradebook exists
} // integrateGradebook
@WebMethod
@Path("/setAssignmentGradeCommentforUser")
@Produces("text/plain")
@GET
public String setAssignmentGradeCommentforUser(
@WebParam(name = "sessionId", partName = "sessionId") @QueryParam("sessionId")
String sessionId,
@WebParam(name = "assignmentId", partName = "assignmentId") @QueryParam("assignmentId")
String assignmentId,
@WebParam(name = "userId", partName = "userId") @QueryParam("userId") String userId,
@WebParam(name = "comment", partName = "comment") @QueryParam("comment") String comment,
@WebParam(name = "grade", partName = "grade") @QueryParam("grade") String grade) {
// establish the session
try {
Session s = establishSession(sessionId);
LOG.info(
"User "
+ s.getUserEid()
+ " setting assignment grade/comment for "
+ userId
+ " on "
+ assignmentId
+ " to "
+ grade);
User user = userDirectoryService.getUserByEid(userId);
if (user == null) {
return "user does not exist";
}
Assignment assign = assignmentService.getAssignment(assignmentId);
String aReference = assign.getReference();
if (!securityService.unlock(
AssignmentService.SECURE_GRADE_ASSIGNMENT_SUBMISSION, aReference)) {
LOG.warn("User " + s.getUserEid() + " does not have permission to set assignment grades");
return "failure: no permission";
}
LOG.info(
"Setting assignment grade/comment for "
+ userId
+ " on "
+ assignmentId
+ " to "
+ grade);
AssignmentSubmission sub = assignmentService.getSubmission(assignmentId, user);
AssignmentSubmissionEdit asEdit = null;
String context = assign.getContext();
if (sub == null) {
asEdit = assignmentService.addSubmission(context, assignmentId, user.getId());
} else {
asEdit = assignmentService.editSubmission(sub.getReference());
}
asEdit.setFeedbackComment(comment);
asEdit.setGrade(grade);
asEdit.setGraded(true);
asEdit.setGradeReleased(true);
assignmentService.commitEdit(asEdit);
// If necessary, update the assignment grade in the Gradebook
String sReference = asEdit.getReference();
String associateGradebookAssignment =
StringUtils.trimToNull(
assign
.getProperties()
.getProperty(AssignmentService.PROP_ASSIGNMENT_ASSOCIATE_GRADEBOOK_ASSIGNMENT));
// update grade in gradebook
integrateGradebook(
aReference,
associateGradebookAssignment,
null,
null,
-1,
null,
sReference,
"update",
context);
} catch (Exception e) {
LOG.error(
"WS setAssignmentGradeCommentforUser(): Exception while setting assignment grade/comment for "
+ userId
+ " on "
+ assignmentId
+ " to "
+ grade,
e);
return e.getClass().getName() + " : " + e.getMessage();
}
return "success";
}