def enroll_student_cohort()

in microservices/lms/src/routes/student.py [0:0]

• 106 lines of code
• 12 McCabe index (conditional complexity)

def enroll_student_cohort(cohort_id: str, input_data: AddStudentModel,
                          request: Request):
  """
  Args:
    input_data(AddStudentToSectionModel):
      An AddStudentToSectionModel object which contains email and credentials
  Raises:
    InternalServerError: 500 Internal Server Error if something fails
    ResourceNotFound : 404 if the section or classroom does not exist
    Conflict: 409 if the student already exists
  Returns:
    AddStudentResponseModel: if the student successfully added,
    NotFoundErrorResponseModel: if the section and course not found,
    ConflictResponseModel: if any conflict occurs,
    InternalServerErrorResponseModel: if the add student raises an exception
  """
  section_id=None
  try:
    cohort = Cohort.find_by_id(cohort_id)
    sections = Section.collection.filter("cohort", "==", cohort.key).filter(
        "deleted_at_timestamp", "==", None).fetch()
    sections = list(sections)
    headers = {"Authorization": request.headers.get("Authorization")}
    if cohort.enrolled_students_count >= cohort.max_students:
      raise ValidationError("Cohort Max count reached hence student cannot" +
                     " be erolled in this cohort")
    if len(sections) == 0:
      raise ValidationError("Given CohortId\
         does not have any sections")
    if not student_service.check_student_can_enroll_in_cohort(
        email=input_data.email, headers=headers, sections=sections):
      raise Conflict(f"Student {input_data.email} is already\
                      enrolled for cohort {cohort_id}")
    section = student_service.get_section_with_minimum_student(sections)
    if section is None:
      raise ValidationError(
        "All sections in chorot are full or not open for enrollment")
    section_id = section.id
    Logger.info(f"Section with minimum student is {section.id},\
                enroll student intiated for {input_data.email}")
    user_object = classroom_crud.enroll_student(
        headers=headers,
        access_token=input_data.access_token,
        student_email=input_data.email,
        course_id=section.classroom_id,
        course_code=section.classroom_code)
    latest_section = Section.find_by_id(section.id)
    latest_cohort = latest_section.cohort
    latest_cohort.enrolled_students_count += 1
    latest_cohort.update()
    latest_section.enrolled_students_count += 1
    latest_section.update()
    course_enrollment_mapping = CourseEnrollmentMapping()
    course_enrollment_mapping.section = section
    course_enrollment_mapping.user = User.find_by_user_id(
        user_object["user_id"])
    course_enrollment_mapping.status = "active"
    course_enrollment_mapping.role = "learner"
    course_enrollment_id = course_enrollment_mapping.save().id
    response_dict = {}
    response_dict = {
        "course_enrollment_id": course_enrollment_id,
        "student_email": input_data.email,
        "section_id": section.id,
        "cohort_id": cohort_id,
        "classroom_id": section.classroom_id,
        "classroom_url": section.classroom_url
    }
    section_service.insert_section_enrollment_to_bq(
      course_enrollment_mapping, section)
    return {
        "message":
        f"Successfully Added the Student with email {input_data.email}",
        "data": response_dict
    }

  except InvalidTokenError as ive:
    err = traceback.format_exc().replace("\n", " ")
    student_service.insert_failure_log(input_data.email, section_id,
                            cohort_id, err, "InvalidTokenError")
    Logger.error(err)
    raise InvalidToken(str(ive)) from ive
  except ResourceNotFoundException as err:
    er = traceback.format_exc().replace("\n", " ")
    student_service.insert_failure_log(input_data.email, section_id,
                            cohort_id, er, "ResourceNotFound")
    Logger.error(err)
    raise ResourceNotFound(str(err)) from err
  except Conflict as conflict:
    Logger.error(conflict)
    err = traceback.format_exc().replace("\n", " ")
    student_service.insert_failure_log(input_data.email, section_id,
                            cohort_id, err, "Conflict")
    Logger.error(err)
    raise Conflict(str(conflict)) from conflict
  except HttpError as ae:
    err = traceback.format_exc().replace("\n", " ")
    student_service.insert_failure_log(input_data.email, section_id,
                            cohort_id, err, "ClassroomHttpException")
    Logger.error(err)
    if ae.resp.status == 409:
      raise ClassroomHttpException(
          status_code=ae.resp.status,
          message="Student already exist in classroom") from ae
    else:
      raise ClassroomHttpException(status_code=ae.resp.status,
                                   message="Can't enroll student to classroom,\
  Please check organizations policy or authentication scopes") from ae
  except ValidationError as ve:
    err = traceback.format_exc().replace("\n", " ")
    student_service.insert_failure_log(input_data.email, section_id,
                            cohort_id, err, "BadRequest")
    Logger.error(ve)
    raise BadRequest(str(ve)) from ve
  except Exception as e:
    Logger.error(e)
    err = traceback.format_exc().replace("\n", " ")
    student_service.insert_failure_log(input_data.email, section_id,
                            cohort_id, err, "InternalServerError")
    Logger.error(err)
    raise InternalServerError(str(e)) from e