def _eval_generic_conditions( rule, # type: Any course, # type: Course participation, # type: Optional[Participation] now_datetime, # type: datetime.datetime flow_id, # type: Text login_exam_ticket, # type: Optional[ExamTicket] ): # type: (...) -> bool if hasattr(rule, "if_before"): ds = parse_date_spec(course, rule.if_before) if not (now_datetime <= ds): return False if hasattr(rule, "if_after"): ds = parse_date_spec(course, rule.if_after) if not (now_datetime >= ds): return False if hasattr(rule, "if_has_role"): from course.enrollment import get_participation_role_identifiers roles = get_participation_role_identifiers(course, participation) if all(role not in rule.if_has_role for role in roles): return False if (hasattr(rule, "if_signed_in_with_matching_exam_ticket") and rule.if_signed_in_with_matching_exam_ticket): if login_exam_ticket is None: return False if login_exam_ticket.exam.flow_id != flow_id: return False return True
def test_set_up_new_course(self): # In this test, we use client instead of request factory to simplify # the logic. with self.temporarily_switch_to_user(self.instructor): # the permission is cached, need to repopulated from db resp = self.get_set_up_new_course() self.assertTrue(resp.status_code, 200) with mock.patch("dulwich.client.GitClient.fetch", return_value={b"HEAD": b"some_commit_sha"}), \ mock.patch("course.versioning.transfer_remote_refs", return_value=None), \ mock.patch("course.validation.validate_course_content", return_value=None): data = self.get_set_up_new_course_form_data() resp = self.post_create_course(data, raise_error=False, login_superuser=False) self.assertTrue(resp.status_code, 200) self.assertEqual(Course.objects.count(), 1) self.assertEqual(Participation.objects.count(), 1) self.assertEqual(Participation.objects.first().user.username, "test_instructor") self.assertAddMessageCalledWith( "Course content validated, creation succeeded.") from course.enrollment import get_participation_role_identifiers # the user who setup the course has role instructor self.assertTrue( get_participation_role_identifiers( Course.objects.first(), Participation.objects.first()), "instructor")
def role_identifiers(self): # type: () -> List[Text] if self._role_identifiers_cache is not None: return self._role_identifiers_cache from course.enrollment import get_participation_role_identifiers self._role_identifiers_cache = get_participation_role_identifiers( self.course, self.participation) return self._role_identifiers_cache
def get_session_grading_rule( session, # type: FlowSession flow_desc, # type: FlowDesc now_datetime # type: datetime.datetime ): # type: (...) -> FlowSessionGradingRule flow_desc_rules = getattr(flow_desc, "rules", None) from relate.utils import dict_to_struct rules = get_flow_rules(flow_desc, flow_rule_kind.grading, session.participation, session.flow_id, now_datetime, default_rules_desc=[ dict_to_struct(dict( generates_grade=False, ))]) from course.enrollment import get_participation_role_identifiers roles = get_participation_role_identifiers(session.course, session.participation) for rule in rules: if hasattr(rule, "if_has_role"): if all(role not in rule.if_has_role for role in roles): continue if not _eval_generic_session_conditions(rule, session, now_datetime): continue if not _eval_participation_tags_conditions(rule, session.participation): continue if hasattr(rule, "if_completed_before"): ds = parse_date_spec(session.course, rule.if_completed_before) if session.in_progress and now_datetime > ds: continue if not session.in_progress and session.completion_time > ds: continue due = parse_date_spec(session.course, getattr(rule, "due", None)) if due is not None: assert due.tzinfo is not None generates_grade = getattr(rule, "generates_grade", True) grade_identifier = None grade_aggregation_strategy = None if flow_desc_rules is not None: grade_identifier = flow_desc_rules.grade_identifier grade_aggregation_strategy = getattr( flow_desc_rules, "grade_aggregation_strategy", None) bonus_points = getattr_with_fallback((rule, flow_desc), "bonus_points", 0) max_points = getattr_with_fallback((rule, flow_desc), "max_points", None) max_points_enforced_cap = getattr_with_fallback( (rule, flow_desc), "max_points_enforced_cap", None) return FlowSessionGradingRule( grade_identifier=grade_identifier, grade_aggregation_strategy=grade_aggregation_strategy, due=due, generates_grade=generates_grade, description=getattr(rule, "description", None), credit_percent=getattr(rule, "credit_percent", 100), use_last_activity_as_completion_time=getattr( rule, "use_last_activity_as_completion_time", False), bonus_points=bonus_points, max_points=max_points, max_points_enforced_cap=max_points_enforced_cap, ) raise RuntimeError(_("grading rule determination was unable to find " "a grading rule"))
def get_session_grading_rule( session, # type: FlowSession flow_desc, # type: FlowDesc now_datetime # type: datetime.datetime ): # type: (...) -> FlowSessionGradingRule flow_desc_rules = getattr(flow_desc, "rules", None) from relate.utils import dict_to_struct rules = get_flow_rules(flow_desc, flow_rule_kind.grading, session.participation, session.flow_id, now_datetime, default_rules_desc=[ dict_to_struct(dict( generates_grade=False, ))]) from course.enrollment import get_participation_role_identifiers roles = get_participation_role_identifiers(session.course, session.participation) for rule in rules: if hasattr(rule, "if_has_role"): if all(role not in rule.if_has_role for role in roles): continue if not _eval_generic_session_conditions(rule, session, now_datetime): continue if not _eval_participation_tags_conditions(rule, session.participation): continue if hasattr(rule, "if_completed_before"): ds = parse_date_spec(session.course, rule.if_completed_before) use_last_activity_as_completion_time = False if hasattr(rule, "use_last_activity_as_completion_time"): use_last_activity_as_completion_time = \ rule.use_last_activity_as_completion_time if use_last_activity_as_completion_time: last_activity = session.last_activity() if last_activity is not None: completion_time = last_activity else: completion_time = now_datetime else: if session.in_progress: completion_time = now_datetime else: completion_time = session.completion_time if completion_time > ds: continue due = parse_date_spec(session.course, getattr(rule, "due", None)) if due is not None: assert due.tzinfo is not None generates_grade = getattr(rule, "generates_grade", True) grade_identifier = None grade_aggregation_strategy = None if flow_desc_rules is not None: grade_identifier = flow_desc_rules.grade_identifier grade_aggregation_strategy = getattr( flow_desc_rules, "grade_aggregation_strategy", None) bonus_points = getattr_with_fallback((rule, flow_desc), "bonus_points", 0) max_points = getattr_with_fallback((rule, flow_desc), "max_points", None) max_points_enforced_cap = getattr_with_fallback( (rule, flow_desc), "max_points_enforced_cap", None) grade_aggregation_strategy = cast(Text, grade_aggregation_strategy) return FlowSessionGradingRule( grade_identifier=grade_identifier, grade_aggregation_strategy=grade_aggregation_strategy, due=due, generates_grade=generates_grade, description=getattr(rule, "description", None), credit_percent=getattr(rule, "credit_percent", 100), use_last_activity_as_completion_time=getattr( rule, "use_last_activity_as_completion_time", False), bonus_points=bonus_points, max_points=max_points, max_points_enforced_cap=max_points_enforced_cap, ) raise RuntimeError(_("grading rule determination was unable to find " "a grading rule"))