def replace_old_assessment()

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

• 90 lines of code
• 18 McCabe index (conditional complexity)

def replace_old_assessment(new_assessment_id: str, old_assessment_id: str,
                           request: Request):
  """
    This endpoint replaces the old assessment with the new assessment,
    and updates the hierarchy along with the subsequent nodes.

    ### Args:
    - old_assessment_id (str): UUID of the original (placeholder) assessment
    - new_assessment_id (str): UUID of the new authored assessment

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

    ### Returns:
    - AssessmentModel: Created Assessment Object
  """
  try:
    # Fetch the details of the placeholder assessment
    placeholder_assessment_data = Assessment.find_by_uuid(old_assessment_id)
    new_assessment = Assessment.find_by_uuid(new_assessment_id)
    new_assessment.parent_nodes = placeholder_assessment_data.parent_nodes
    new_assessment.order = placeholder_assessment_data.order
    new_assessment.prerequisites = placeholder_assessment_data.prerequisites

    # Identify the nodes to update the node pre-reqs
    if "learning_objects" in placeholder_assessment_data.parent_nodes:

      headers = {"Authorization": request.headers.get("Authorization")}
      API_URL = "http://{}:{}/learning-object-service/api/v1/{}/{}"

      if placeholder_assessment_data.parent_nodes.get(
          "learning_objects", None) and len(
              placeholder_assessment_data.parent_nodes.get(
                  "learning_objects", [])) >= 1:
        learning_object_id = placeholder_assessment_data.parent_nodes.get(
            "learning_objects")[0]
        learning_object = LearningObject.find_by_uuid(learning_object_id)
        neighbour_nodes = learning_object.child_nodes

        # Check the neighboring learning_resource nodes
        if "learning_resources" in neighbour_nodes:
          dependent_lr_nodes = neighbour_nodes.get("learning_resources", [])
          for lr in dependent_lr_nodes:
            lr_data = LearningResource.find_by_uuid(lr).to_dict()
            if lr_data["order"] > placeholder_assessment_data.order:
              for i in range(len(lr_data["prerequisites"]\
                                 .get("assessments",[]))):
                if lr_data["prerequisites"]["assessments"][i] ==\
                  old_assessment_id:
                  lr_data["prerequisites"]["assessments"][i] = new_assessment_id

                  request_body = {
                      "prerequisites": {
                          "assessments": lr_data["prerequisites"]["assessments"]
                      }
                  }
                  api_url = API_URL.format(
                      SERVICES["learning-object-service"]["host"],
                      SERVICES["learning-object-service"]["port"],
                      "learning-resource", lr_data["uuid"])
                  query_params = {"create_version": False}
                  response = requests.put(
                      url=api_url,
                      params=query_params,
                      json=request_body,
                      headers=headers)
                  if response.status_code != 200:
                    raise ResourceNotFoundException(response.message)

        # Check the neighboring assessment nodes
        if "assessments" in neighbour_nodes:
          dependent_assessment_nodes = neighbour_nodes.get("assessments", [])
          for assessment in dependent_assessment_nodes:
            assessment_data = Assessment.find_by_uuid(assessment)
            if (assessment_data.order > placeholder_assessment_data.order) and (
                old_assessment_id in assessment_data.prerequisites.get(
                    "assessments", [])):
              prerequisites = assessment_data.prerequisites.get("assessments")
              prerequisites.remove(old_assessment_id)
              prerequisites.append(new_assessment_id)
              assessment_data.prerequisites["assessments"] = prerequisites
              assessment_data.update()

          assessments = learning_object.child_nodes.get("assessments", [])
          assessments.remove(old_assessment_id)
          assessments.append(new_assessment_id)

          request_body = {"child_nodes": {"assessments": assessments}}
          api_url = API_URL.format(SERVICES["learning-object-service"]["host"],
                                   SERVICES["learning-object-service"]["port"],
                                   "learning-object", learning_object_id)
          response = requests.put(
              url=api_url, json=request_body, headers=headers)
          if response.status_code != 200:
            raise ResourceNotFoundException(response.message)

        #Remove or unlink the placeholder assessment
        placeholder_assessment_data.parent_nodes = {}
        placeholder_assessment_data.order = None
        placeholder_assessment_data.prerequisites = {}
        placeholder_assessment_data.update()

    new_assessment.update()
    authored_assessment = Assessment.find_by_uuid(new_assessment_id)
    authored_assessment_data = authored_assessment.get_fields(
        reformat_datetime=True)

    return {
        "success": True,
        "message": "Successfully linked the assessment",
        "data": authored_assessment_data
    }

  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