def update_assessment_item()

in microservices/assessment_service/src/routes/submitted_assessment.py [0:0]

• 71 lines of code
• 22 McCabe index (conditional complexity)

def update_assessment_item(
    uuid: str, input_submitted_assessment: UpdateSubmittedAssessmentModel):
  """
    Update a submitted_assessment

    ### Args:
    - input_submitted_assessment (UpdateSubmittedAssessmentModel):
    Required body of submitted_assessment

    ### Raises:
    - ResourceNotFoundException: If the submitted_assessment does not exist
    - Exception: 500 Internal Server Error if something went wrong

    ### Returns:
    - SubmittedAssessmentResponseModel: SubmittedAssessment Object
  """
  try:
    submitted_assessment = SubmittedAssessment.find_by_uuid(uuid)
    submitted_assessment_dict = {**input_submitted_assessment.dict()}
    submitted_assessment_fields = submitted_assessment.get_fields()

    # Update status, pass_status, and result based on submitted_rubrics
    evaluated = False
    if submitted_assessment_fields.get("type") in \
      ["srl", "static_srl", "cognitive_wrapper"] and \
      submitted_assessment_fields.get("is_autogradable", False):
      # Always pass SRL assessments
      pass_status = True
      result = "Pass"
      status = "completed"
      evaluated = True
    else:
      submitted_rubrics = submitted_assessment_dict.get("submitted_rubrics",
                                                        None)
      if submitted_rubrics is not None:
        assessment_id = submitted_assessment.assessment_id
        assessment = Assessment.find_by_uuid(assessment_id)
        if assessment.child_nodes and "rubrics" in assessment.child_nodes:
          # FIXME: Assumption: only one rubric for each assessment
          rubric_id = assessment.child_nodes["rubrics"][0]
          rubric = Rubric.find_by_uuid(rubric_id)
          criteria = rubric.evaluation_criteria
          criteria = {v: k for k, v in criteria.items()}
          if len(submitted_rubrics):
            pass_status = True
            result = "Exemplary"
            for r_criterion in submitted_assessment_dict["submitted_rubrics"]:
              if criteria[r_criterion["result"]] > criteria[result]:
                result = r_criterion["result"]
            if criteria[result] > criteria["Proficient"]:
              pass_status = False
              status = "evaluated"
            else:
              status = "completed"
            evaluated = True
    if evaluated:
      submitted_assessment_dict["status"] = status
      submitted_assessment_dict["result"] = result
      submitted_assessment_dict["pass_status"] = pass_status

    for key, value in submitted_assessment_dict.items():
      if key == "comments" and value is not None:
        if value.get("created_time") is None:
          value["created_time"] = str(datetime.now())
        if submitted_assessment_fields.get("comments"):
          value = [value] + submitted_assessment_fields.get(
              "comments", [])
        else:
          value = [value]
      submitted_assessment_fields[key] = value
    for key, value in submitted_assessment_fields.items():
      setattr(submitted_assessment, key, value)

    submitted_assessment.update()

    submitted_assessment_fields = submitted_assessment.get_fields(
        reformat_datetime=True)
    submitted_assessment_fields["timer_start_time"] = str(
        submitted_assessment_fields["timer_start_time"])

    return {
        "success": True,
        "message": "Successfully updated the submitted assessment.",
        "data": submitted_assessment_fields
    }
  except ResourceNotFoundException as e:
    Logger.error(e)
    Logger.error(traceback.print_exc())
    raise ResourceNotFound(str(e)) from e
  except Exception as e:
    Logger.error(e)
    Logger.error(traceback.print_exc())
    raise InternalServerError(str(e)) from e