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 _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 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 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"))
