/** {@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;
 }
Ejemplo n.º 2
0
  @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;
 }
Ejemplo n.º 6
0
  /**
   * @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
Ejemplo n.º 7
0
  @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";
  }