def get_session_grading_rule_1_day_due_side_effect(session, flow_desc,
now_datetime):
from course.utils import get_session_grading_rule
actual_grading_rule = get_session_grading_rule(session, flow_desc,
now_datetime)
actual_grading_rule.due = now() + timedelta(days=1)
return actual_grading_rule
def expire_flow_session_standalone(repo, course, session, now_datetime, past_due_only=False):
assert session.participation is not None
from course.utils import FlowContext
fctx = FlowContext(repo, course, session.flow_id, flow_session=session)
grading_rule = get_session_grading_rule(session, session.participation.role, fctx.flow_desc, now_datetime)
return expire_flow_session(fctx, session, grading_rule, now_datetime, past_due_only=past_due_only)
def _save_grade(fpctx, flow_session, most_recent_grade, bulk_feedback_json,
now_datetime):
most_recent_grade.save()
update_bulk_feedback(
fpctx.prev_answer_visit.page_data,
most_recent_grade,
bulk_feedback_json)
grading_rule = get_session_grading_rule(
flow_session, flow_session.participation.role,
fpctx.flow_desc, now_datetime)
from course.flow import grade_flow_session
grade_flow_session(fpctx, flow_session, grading_rule)
def _save_grade(
fpctx, # type: FlowPageContext
flow_session, # type: FlowSession
most_recent_grade, # type: FlowPageVisitGrade
bulk_feedback_json, # type: Any
now_datetime, # type: datetime.datetime
):
# type: (...) -> None
most_recent_grade.save()
update_bulk_feedback(fpctx.prev_answer_visit.page_data, most_recent_grade,
bulk_feedback_json)
grading_rule = get_session_grading_rule(flow_session, fpctx.flow_desc,
now_datetime)
from course.flow import grade_flow_session
grade_flow_session(fpctx, flow_session, grading_rule)
def finish_flow_session_standalone(repo, course, session, force_regrade=False, now_datetime=None, past_due_only=False):
assert session.participation is not None
from course.utils import FlowContext
if now_datetime is None:
from django.utils.timezone import now
now_datetime = now()
fctx = FlowContext(repo, course, session.flow_id, flow_session=session)
grading_rule = get_session_grading_rule(session, session.participation.role, fctx.flow_desc, now_datetime)
if past_due_only and grading_rule.due is not None and now_datetime < grading_rule.due:
return False
finish_flow_session(fctx, session, grading_rule, force_regrade=force_regrade, now_datetime=now_datetime)
return True
def get_session_grading_rule_side_effect(session, flow_desc, now_datetime):
from course.utils import (
get_session_grading_rule, FlowSessionGradingRule)
true_g_rule = get_session_grading_rule(
session, flow_desc, now_datetime)
fake_grading_rule = FlowSessionGradingRule(
# make grade_identifier None
grade_identifier=None,
grade_aggregation_strategy=true_g_rule.grade_aggregation_strategy,
due=true_g_rule.due,
generates_grade=true_g_rule.generates_grade,
description=true_g_rule.description,
credit_percent=true_g_rule.credit_percent,
use_last_activity_as_completion_time=(
true_g_rule.use_last_activity_as_completion_time),
bonus_points=true_g_rule.bonus_points,
max_points=true_g_rule.max_points,
max_points_enforced_cap=true_g_rule.max_points_enforced_cap)
return fake_grading_rule
def get_session_grading_rule_side_effect(session, flow_desc,
now_datetime):
from course.utils import (get_session_grading_rule,
FlowSessionGradingRule)
true_g_rule = get_session_grading_rule(session, flow_desc,
now_datetime)
fake_grading_rule = FlowSessionGradingRule(
# make grade_identifier None
grade_identifier=None,
grade_aggregation_strategy=true_g_rule.
grade_aggregation_strategy,
due=true_g_rule.due,
generates_grade=true_g_rule.generates_grade,
description=true_g_rule.description,
credit_percent=true_g_rule.credit_percent,
use_last_activity_as_completion_time=(
true_g_rule.use_last_activity_as_completion_time),
bonus_points=true_g_rule.bonus_points,
max_points=true_g_rule.max_points,
max_points_enforced_cap=true_g_rule.max_points_enforced_cap)
return fake_grading_rule
def view_single_grade(pctx, participation_id, opportunity_id):
now_datetime = get_now_or_fake_time(pctx.request)
participation = get_object_or_404(Participation,
id=int(participation_id))
if participation.course != pctx.course:
raise SuspiciousOperation(_("participation does not match course"))
opportunity = get_object_or_404(GradingOpportunity, id=int(opportunity_id))
if pctx.role in [
participation_role.instructor,
participation_role.teaching_assistant]:
if not opportunity.shown_in_grade_book:
messages.add_message(pctx.request, messages.INFO,
_("This grade is not shown in the grade book."))
if not opportunity.shown_in_student_grade_book:
messages.add_message(pctx.request, messages.INFO,
_("This grade is not shown in the student grade book."))
elif pctx.role == participation_role.student:
if participation != pctx.participation:
raise PermissionDenied(_("may not view other people's grades"))
if not (opportunity.shown_in_grade_book
and opportunity.shown_in_student_grade_book):
raise PermissionDenied(_("grade has not been released"))
else:
raise PermissionDenied()
# {{{ modify sessions buttons
if pctx.role in [
participation_role.instructor,
participation_role.teaching_assistant]:
allow_session_actions = True
request = pctx.request
if pctx.request.method == "POST":
action_re = re.compile("^([a-z]+)_([0-9]+)$")
for key in request.POST.keys():
action_match = action_re.match(key)
if action_match:
break
if not action_match:
raise SuspiciousOperation(_("unknown action"))
session = FlowSession.objects.get(id=int(action_match.group(2)))
op = action_match.group(1)
from course.flow import (
regrade_session,
recalculate_session_grade,
expire_flow_session_standalone,
finish_flow_session_standalone)
try:
if op == "expire":
expire_flow_session_standalone(
pctx.repo, pctx.course, session, now_datetime)
messages.add_message(pctx.request, messages.SUCCESS,
_("Session expired."))
elif op == "end":
finish_flow_session_standalone(
pctx.repo, pctx.course, session,
now_datetime=now_datetime)
messages.add_message(pctx.request, messages.SUCCESS,
_("Session ended."))
elif op == "regrade":
regrade_session(
pctx.repo, pctx.course, session)
messages.add_message(pctx.request, messages.SUCCESS,
_("Session regraded."))
elif op == "recalculate":
recalculate_session_grade(
pctx.repo, pctx.course, session)
messages.add_message(pctx.request, messages.SUCCESS,
_("Session grade recalculated."))
else:
raise SuspiciousOperation(_("invalid session operation"))
except Exception as e:
messages.add_message(pctx.request, messages.ERROR,
string_concat(
pgettext_lazy("Starting of Error message",
"Error"),
": %(err_type)s %(err_str)s")
% {
"err_type": type(e).__name__,
"err_str": str(e)})
else:
allow_session_actions = False
# }}}
grade_changes = list(GradeChange.objects
.filter(
opportunity=opportunity,
participation=participation)
.order_by("grade_time")
.select_related("participation")
.select_related("participation__user")
.select_related("creator")
.select_related("opportunity"))
state_machine = GradeStateMachine()
state_machine.consume(grade_changes, set_is_superseded=True)
if opportunity.flow_id:
flow_sessions = list(FlowSession.objects
.filter(
participation=participation,
flow_id=opportunity.flow_id,
)
.order_by("start_time"))
from collections import namedtuple
SessionProperties = namedtuple( # noqa
"SessionProperties",
["due", "grade_description"])
from course.utils import get_session_grading_rule
from course.content import get_flow_desc
try:
flow_desc = get_flow_desc(pctx.repo, pctx.course,
opportunity.flow_id, pctx.course_commit_sha)
except ObjectDoesNotExist:
flow_sessions_and_session_properties = None
else:
flow_sessions_and_session_properties = []
for session in flow_sessions:
grading_rule = get_session_grading_rule(
session, pctx.role, flow_desc, now_datetime)
session_properties = SessionProperties(
due=grading_rule.due,
grade_description=grading_rule.description)
flow_sessions_and_session_properties.append(
(session, session_properties))
else:
flow_sessions_and_session_properties = None
avg_grade_percentage, avg_grade_population = average_grade(opportunity)
return render_course_page(pctx, "course/gradebook-single.html", {
"opportunity": opportunity,
"avg_grade_percentage": avg_grade_percentage,
"avg_grade_population": avg_grade_population,
"grade_participation": participation,
"grade_state_change_types": grade_state_change_types,
"grade_changes": grade_changes,
"state_machine": state_machine,
"flow_sessions_and_session_properties": flow_sessions_and_session_properties,
"allow_session_actions": allow_session_actions,
"show_privileged_info": pctx.role in [
participation_role.instructor,
participation_role.teaching_assistant
],
})
def grant_exception_stage_3(pctx, participation_id, flow_id, session_id):
if pctx.role not in [
participation_role.instructor,
participation_role.teaching_assistant]:
raise PermissionDenied("must be instructor or TA to grant exceptions")
participation = get_object_or_404(Participation, id=participation_id)
from course.content import get_flow_desc
try:
flow_desc = get_flow_desc(pctx.repo, pctx.course, flow_id,
pctx.course_commit_sha)
except ObjectDoesNotExist:
raise http.Http404()
session = FlowSession.objects.get(id=int(session_id))
now_datetime = get_now_or_fake_time(pctx.request)
from course.utils import (
get_session_access_rule,
get_session_grading_rule)
access_rule = get_session_access_rule(
session, pctx.role, flow_desc, now_datetime)
grading_rule = get_session_grading_rule(
session, pctx.role, flow_desc, now_datetime)
request = pctx.request
if request.method == "POST":
form = ExceptionStage3Form({}, session.access_rules_tag, request.POST)
from course.constants import flow_rule_kind
if form.is_valid():
permissions = [
key
for key, _ in FLOW_PERMISSION_CHOICES
if form.cleaned_data[key]]
from course.validation import (
validate_session_access_rule,
validate_session_grading_rule,
ValidationContext)
from relate.utils import dict_to_struct
vctx = ValidationContext(
repo=pctx.repo,
commit_sha=pctx.course_commit_sha)
from course.content import get_flow_desc
flow_desc = get_flow_desc(pctx.repo,
pctx.course,
flow_id, pctx.course_commit_sha)
tags = None
if hasattr(flow_desc, "rules"):
tags = getattr(flow_desc.rules, "tags", None)
# {{{ put together access rule
new_access_rule = {"permissions": permissions}
if (form.cleaned_data["restrict_to_same_tag"]
and session.access_rules_tag is not None):
new_access_rule["if_has_tag"] = session.access_rules_tag
validate_session_access_rule(vctx, "newly created exception",
dict_to_struct(new_access_rule), tags)
fre_access = FlowRuleException(
flow_id=flow_id,
participation=participation,
expiration=form.cleaned_data["access_expires"],
creator=pctx.request.user,
comment=form.cleaned_data["comment"],
kind=flow_rule_kind.access,
rule=new_access_rule)
fre_access.save()
# }}}
# {{{ put together grading rule
due = form.cleaned_data["due"]
if form.cleaned_data["due_same_as_access_expiration"]:
due = form.cleaned_data["access_expires"]
descr = "Granted excecption"
if form.cleaned_data["credit_percent"] is not None:
descr += " (%.1f%% credit)" % form.cleaned_data["credit_percent"]
from relate.utils import as_local_time
new_grading_rule = {
"credit_percent": form.cleaned_data["credit_percent"],
"due": as_local_time(due).replace(tzinfo=None),
"if_completed_before": as_local_time(due).replace(tzinfo=None),
"description": descr,
}
if (form.cleaned_data["restrict_to_same_tag"]
and session.access_rules_tag is not None):
new_grading_rule["if_has_tag"] = session.access_rules_tag
if hasattr(grading_rule, "grade_identifier"):
new_grading_rule["grade_identifier"] = \
grading_rule.grade_identifier
if hasattr(grading_rule, "grade_aggregation_strategy"):
new_grading_rule["grade_aggregation_strategy"] = \
grading_rule.grade_aggregation_strategy
validate_session_grading_rule(vctx, "newly created exception",
dict_to_struct(new_grading_rule), tags)
fre_grading = FlowRuleException(
flow_id=flow_id,
participation=participation,
creator=pctx.request.user,
comment=form.cleaned_data["comment"],
kind=flow_rule_kind.grading,
rule=new_grading_rule)
fre_grading.save()
# }}}
messages.add_message(pctx.request, messages.SUCCESS,
"Exception granted to '%s' for '%s'." % (participation, flow_id))
return redirect(
"course.views.grant_exception",
pctx.course.identifier)
else:
data = {
"restrict_to_same_tag": session.access_rules_tag is not None,
"credit_percent": grading_rule.credit_percent,
#"due_same_as_access_expiration": True,
"due": grading_rule.due,
}
for perm in access_rule.permissions:
data[perm] = True
form = ExceptionStage3Form(data, session.access_rules_tag)
return render_course_page(pctx, "course/generic-course-form.html", {
"form": form,
"form_description": "Grant Exception",
"form_text": "<div class='well'>Granting exception to '%s' for '%s'.</div>"
% (participation, flow_id),
})
def grade_flow_page(pctx, flow_session_id, page_ordinal):
# type: (CoursePageContext, int, int) -> http.HttpResponse
now_datetime = get_now_or_fake_time(pctx.request)
page_ordinal = int(page_ordinal)
viewing_prev_grade = False
prev_grade_id = pctx.request.GET.get("grade_id")
if prev_grade_id is not None:
try:
prev_grade_id = int(prev_grade_id)
viewing_prev_grade = True
except ValueError:
raise SuspiciousOperation("non-integer passed for 'grade_id'")
if not pctx.has_permission(pperm.view_gradebook):
raise PermissionDenied(_("may not view grade book"))
flow_session = get_object_or_404(FlowSession, id=int(flow_session_id))
if flow_session.course.pk != pctx.course.pk:
raise SuspiciousOperation(
_("Flow session not part of specified course"))
if flow_session.participation is None:
raise SuspiciousOperation(_("Cannot grade anonymous session"))
from course.flow import adjust_flow_session_page_data
adjust_flow_session_page_data(pctx.repo,
flow_session,
pctx.course.identifier,
respect_preview=False)
fpctx = FlowPageContext(pctx.repo,
pctx.course,
flow_session.flow_id,
page_ordinal,
participation=flow_session.participation,
flow_session=flow_session,
request=pctx.request)
if fpctx.page_desc is None:
raise http.Http404()
assert fpctx.page is not None
assert fpctx.page_context is not None
# {{{ enable flow session zapping
all_flow_sessions = list(
FlowSession.objects.filter(course=pctx.course,
flow_id=flow_session.flow_id,
participation__isnull=False,
in_progress=flow_session.in_progress).
order_by(
# Datatables will default to sorting the user list
# by the first column, which happens to be the username.
# Match that sorting.
"participation__user__username",
"start_time"))
next_flow_session_id = None
prev_flow_session_id = None
for i, other_flow_session in enumerate(all_flow_sessions):
if other_flow_session.pk == flow_session.pk:
if i > 0:
prev_flow_session_id = all_flow_sessions[i - 1].id
if i + 1 < len(all_flow_sessions):
next_flow_session_id = all_flow_sessions[i + 1].id
# }}}
prev_grades = get_prev_visit_grades(pctx.course_identifier,
flow_session_id, page_ordinal)
# {{{ reproduce student view
form = None
feedback = None
answer_data = None
grade_data = None
shown_grade = None
page_expects_answer = fpctx.page.expects_answer()
if page_expects_answer:
if fpctx.prev_answer_visit is not None and prev_grade_id is None:
answer_data = fpctx.prev_answer_visit.answer
shown_grade = fpctx.prev_answer_visit.get_most_recent_grade()
if shown_grade is not None:
feedback = get_feedback_for_grade(shown_grade)
grade_data = shown_grade.grade_data
else:
feedback = None
grade_data = None
if shown_grade is not None:
prev_grade_id = shown_grade.id
elif prev_grade_id is not None:
try:
shown_grade = prev_grades.filter(id=prev_grade_id).get()
except ObjectDoesNotExist:
raise http.Http404()
feedback = get_feedback_for_grade(shown_grade)
grade_data = shown_grade.grade_data
answer_data = shown_grade.visit.answer
else:
feedback = None
from course.page.base import PageBehavior
page_behavior = PageBehavior(show_correctness=True,
show_answer=False,
may_change_answer=False)
try:
form = fpctx.page.make_form(fpctx.page_context,
fpctx.page_data.data, answer_data,
page_behavior)
except InvalidPageData as e:
messages.add_message(
pctx.request, messages.ERROR,
_("The page data stored in the database was found "
"to be invalid for the page as given in the "
"course content. Likely the course content was "
"changed in an incompatible way (say, by adding "
"an option to a choice question) without changing "
"the question ID. The precise error encountered "
"was the following: ") + str(e))
return render_course_page(pctx, "course/course-base.html", {})
if form is not None:
form_html = fpctx.page.form_to_html(pctx.request, fpctx.page_context,
form, answer_data)
else:
form_html = None
# }}}
# {{{ grading form
if (page_expects_answer and fpctx.page.is_answer_gradable()
and fpctx.prev_answer_visit is not None
and not flow_session.in_progress and not viewing_prev_grade):
request = pctx.request
if pctx.request.method == "POST":
if not pctx.has_permission(pperm.assign_grade):
raise PermissionDenied(_("may not assign grades"))
grading_form = fpctx.page.post_grading_form(
fpctx.page_context, fpctx.page_data, grade_data, request.POST,
request.FILES)
if grading_form.is_valid():
grade_data = fpctx.page.update_grade_data_from_grading_form_v2(
request, fpctx.page_context, fpctx.page_data, grade_data,
grading_form, request.FILES)
from course.utils import LanguageOverride
with LanguageOverride(pctx.course):
feedback = fpctx.page.grade(fpctx.page_context,
fpctx.page_data.data,
answer_data, grade_data)
if feedback is not None:
correctness = feedback.correctness
else:
correctness = None
feedback_json = None # type: Optional[Dict[Text, Any]]
bulk_feedback_json = None # type: Optional[Dict[Text, Any]]
if feedback is not None:
feedback_json, bulk_feedback_json = feedback.as_json()
else:
feedback_json = bulk_feedback_json = None
most_recent_grade = FlowPageVisitGrade(
visit=fpctx.prev_answer_visit,
grader=pctx.request.user,
graded_at_git_commit_sha=pctx.course_commit_sha,
grade_data=grade_data,
max_points=fpctx.page.max_points(fpctx.page_data),
correctness=correctness,
feedback=feedback_json)
prev_grade_id = _save_grade(fpctx, flow_session,
most_recent_grade,
bulk_feedback_json, now_datetime)
else:
grading_form = fpctx.page.make_grading_form(
fpctx.page_context, fpctx.page_data, grade_data)
else:
grading_form = None
grading_form_html = None # type: Optional[Text]
if grading_form is not None:
from crispy_forms.layout import Submit
grading_form.helper.form_class += " relate-grading-form"
grading_form.helper.add_input(
Submit("submit",
_("Submit"),
accesskey="s",
css_class="relate-grading-save-button"))
grading_form_html = fpctx.page.grading_form_to_html(
pctx.request, fpctx.page_context, grading_form, grade_data)
# }}}
# {{{ compute points_awarded
max_points = None
points_awarded = None
if (page_expects_answer and fpctx.page.is_answer_gradable()):
max_points = fpctx.page.max_points(fpctx.page_data)
if feedback is not None and feedback.correctness is not None:
points_awarded = max_points * feedback.correctness
# }}}
grading_rule = get_session_grading_rule(flow_session, fpctx.flow_desc,
get_now_or_fake_time(pctx.request))
if grading_rule.grade_identifier is not None:
grading_opportunity = get_flow_grading_opportunity(
pctx.course, flow_session.flow_id, fpctx.flow_desc,
grading_rule.grade_identifier, grading_rule.
grade_aggregation_strategy) # type: Optional[GradingOpportunity]
else:
grading_opportunity = None
return render_course_page(
pctx,
"course/grade-flow-page.html",
{
"flow_identifier":
fpctx.flow_id,
"flow_session":
flow_session,
"flow_desc":
fpctx.flow_desc,
"page_ordinal":
fpctx.page_ordinal,
"page_data":
fpctx.page_data,
"body":
fpctx.page.body(fpctx.page_context, fpctx.page_data.data),
"form":
form,
"form_html":
form_html,
"feedback":
feedback,
"max_points":
max_points,
"points_awarded":
points_awarded,
"shown_grade":
shown_grade,
"prev_grade_id":
prev_grade_id,
"expects_answer":
page_expects_answer,
"grading_opportunity":
grading_opportunity,
"prev_flow_session_id":
prev_flow_session_id,
"next_flow_session_id":
next_flow_session_id,
"grading_form":
grading_form,
"grading_form_html":
grading_form_html,
"correct_answer":
fpctx.page.correct_answer(fpctx.page_context, fpctx.page_data.data,
answer_data, grade_data),
# Wrappers used by JavaScript template (tmpl) so as not to
# conflict with Django template's tag wrapper
"JQ_OPEN":
'{%',
'JQ_CLOSE':
'%}',
})
def grant_exception_stage_3(pctx, participation_id, flow_id, session_id):
# type: (CoursePageContext, int, Text, int) -> http.HttpResponse
if not pctx.has_permission(pperm.grant_exception):
raise PermissionDenied(_("may not grant exceptions"))
participation = get_object_or_404(Participation, id=participation_id)
from course.content import get_flow_desc
try:
flow_desc = get_flow_desc(pctx.repo, pctx.course, flow_id,
pctx.course_commit_sha)
except ObjectDoesNotExist:
raise http.Http404()
session = FlowSession.objects.get(id=int(session_id))
now_datetime = get_now_or_fake_time(pctx.request)
from course.utils import (get_session_access_rule,
get_session_grading_rule)
access_rule = get_session_access_rule(session, flow_desc, now_datetime)
grading_rule = get_session_grading_rule(session, flow_desc, now_datetime)
request = pctx.request
if request.method == "POST":
form = ExceptionStage3Form({}, flow_desc, session.access_rules_tag,
request.POST)
from course.constants import flow_rule_kind
if form.is_valid():
permissions = [
key for key, _ in FLOW_PERMISSION_CHOICES
if form.cleaned_data[key]
]
from course.validation import (validate_session_access_rule,
validate_session_grading_rule,
ValidationContext)
from relate.utils import dict_to_struct
vctx = ValidationContext(repo=pctx.repo,
commit_sha=pctx.course_commit_sha)
flow_desc = get_flow_desc(pctx.repo, pctx.course, flow_id,
pctx.course_commit_sha)
tags = [] # type: List[Text]
if hasattr(flow_desc, "rules"):
try:
from typing import Text # noqa
except ImportError:
Text = None # noqa
tags = cast(List[Text], getattr(flow_desc.rules, "tags",
[])) # type: ignore # noqa
# {{{ put together access rule
if form.cleaned_data["create_access_exception"]:
new_access_rule = {"permissions": permissions}
if (form.cleaned_data.get("restrict_to_same_tag")
and session.access_rules_tag is not None):
new_access_rule["if_has_tag"] = session.access_rules_tag
validate_session_access_rule(
vctx, ugettext("newly created exception"),
dict_to_struct(new_access_rule), tags)
fre_access = FlowRuleException(
flow_id=flow_id,
participation=participation,
expiration=form.cleaned_data["access_expires"],
creator=pctx.request.user,
comment=form.cleaned_data["comment"],
kind=flow_rule_kind.access,
rule=new_access_rule)
fre_access.save()
# }}}
new_access_rules_tag = form.cleaned_data.get(
"set_access_rules_tag")
if new_access_rules_tag == NONE_SESSION_TAG:
new_access_rules_tag = None
if session.access_rules_tag != new_access_rules_tag:
session.access_rules_tag = new_access_rules_tag
session.save()
# {{{ put together grading rule
if form.cleaned_data["create_grading_exception"]:
due = form.cleaned_data["due"]
if form.cleaned_data["due_same_as_access_expiration"]:
due = form.cleaned_data["access_expires"]
descr = ugettext("Granted excecption")
if form.cleaned_data["credit_percent"] is not None:
descr += string_concat(" (%.1f%% ", ugettext('credit'), ")") \
% form.cleaned_data["credit_percent"]
due_local_naive = due
if due_local_naive is not None:
from relate.utils import as_local_time
due_local_naive = (as_local_time(due_local_naive).replace(
tzinfo=None))
new_grading_rule = {
"description": descr,
}
if due_local_naive is not None:
new_grading_rule["due"] = due_local_naive
new_grading_rule["if_completed_before"] = due_local_naive
for attr_name in [
"credit_percent", "bonus_points", "max_points",
"max_points_enforced_cap", "generates_grade"
]:
if form.cleaned_data[attr_name] is not None:
new_grading_rule[attr_name] = form.cleaned_data[
attr_name]
if (form.cleaned_data.get("restrict_to_same_tag")
and session.access_rules_tag is not None):
new_grading_rule["if_has_tag"] = session.access_rules_tag
validate_session_grading_rule(
vctx, ugettext("newly created exception"),
dict_to_struct(new_grading_rule), tags,
grading_rule.grade_identifier)
fre_grading = FlowRuleException(
flow_id=flow_id,
participation=participation,
creator=pctx.request.user,
comment=form.cleaned_data["comment"],
kind=flow_rule_kind.grading,
rule=new_grading_rule)
fre_grading.save()
# }}}
messages.add_message(
pctx.request, messages.SUCCESS,
ugettext("Exception granted to '%(participation)s' "
"for '%(flow_id)s'.") % {
'participation': participation,
'flow_id': flow_id
})
return redirect("relate-grant_exception", pctx.course.identifier)
else:
data = {
"restrict_to_same_tag": session.access_rules_tag is not None,
#"due_same_as_access_expiration": True,
"due": grading_rule.due,
"generates_grade": grading_rule.generates_grade,
"credit_percent": grading_rule.credit_percent,
"bonus_points": grading_rule.bonus_points,
"max_points": grading_rule.max_points,
"max_points_enforced_cap": grading_rule.max_points_enforced_cap,
}
for perm in access_rule.permissions:
data[perm] = True
form = ExceptionStage3Form(data, flow_desc, session.access_rules_tag)
return render_course_page(
pctx, "course/generic-course-form.html", {
"form": form,
"form_description": ugettext("Grant Exception"),
"form_text": string_concat(
"<div class='well'>",
ugettext("Granting exception to '%(participation)s' "
"for '%(flow_id)s' (session %(session)s)."), "</div>")
% {
'participation': participation,
'flow_id': flow_id,
'session': strify_session_for_exception(session)
},
})
def grant_exception_stage_3(pctx, participation_id, flow_id, session_id):
# type: (CoursePageContext, int, Text, int) -> http.HttpResponse
if not pctx.has_permission(pperm.grant_exception):
raise PermissionDenied(_("may not grant exceptions"))
participation = get_object_or_404(Participation, id=participation_id)
from course.content import get_flow_desc
try:
flow_desc = get_flow_desc(pctx.repo, pctx.course, flow_id,
pctx.course_commit_sha)
except ObjectDoesNotExist:
raise http.Http404()
session = FlowSession.objects.get(id=int(session_id))
now_datetime = get_now_or_fake_time(pctx.request)
from course.utils import (
get_session_access_rule,
get_session_grading_rule)
access_rule = get_session_access_rule(session, flow_desc, now_datetime)
grading_rule = get_session_grading_rule(session, flow_desc, now_datetime)
request = pctx.request
if request.method == "POST":
form = ExceptionStage3Form(
{}, flow_desc, session.access_rules_tag, request.POST)
from course.constants import flow_rule_kind
if form.is_valid():
permissions = [
key
for key, _ in FLOW_PERMISSION_CHOICES
if form.cleaned_data[key]]
from course.validation import (
validate_session_access_rule,
validate_session_grading_rule,
ValidationContext)
from relate.utils import dict_to_struct
vctx = ValidationContext(
repo=pctx.repo,
commit_sha=pctx.course_commit_sha)
flow_desc = get_flow_desc(pctx.repo,
pctx.course,
flow_id, pctx.course_commit_sha)
tags = None
if hasattr(flow_desc, "rules"):
tags = getattr(flow_desc.rules, "tags", None)
# {{{ put together access rule
if form.cleaned_data["create_access_exception"]:
new_access_rule = {"permissions": permissions}
if (form.cleaned_data.get("restrict_to_same_tag")
and session.access_rules_tag is not None):
new_access_rule["if_has_tag"] = session.access_rules_tag
validate_session_access_rule(
vctx, ugettext("newly created exception"),
dict_to_struct(new_access_rule), tags)
fre_access = FlowRuleException(
flow_id=flow_id,
participation=participation,
expiration=form.cleaned_data["access_expires"],
creator=pctx.request.user,
comment=form.cleaned_data["comment"],
kind=flow_rule_kind.access,
rule=new_access_rule)
fre_access.save()
# }}}
new_access_rules_tag = form.cleaned_data.get("set_access_rules_tag")
if new_access_rules_tag == NONE_SESSION_TAG:
new_access_rules_tag = None
if session.access_rules_tag != new_access_rules_tag:
session.access_rules_tag = new_access_rules_tag
session.save()
# {{{ put together grading rule
if form.cleaned_data["create_grading_exception"]:
due = form.cleaned_data["due"]
if form.cleaned_data["due_same_as_access_expiration"]:
due = form.cleaned_data["access_expires"]
descr = ugettext("Granted excecption")
if form.cleaned_data["credit_percent"] is not None:
descr += string_concat(" (%.1f%% ", ugettext('credit'), ")") \
% form.cleaned_data["credit_percent"]
due_local_naive = due
if due_local_naive is not None:
from relate.utils import as_local_time
due_local_naive = (
as_local_time(due_local_naive)
.replace(tzinfo=None))
new_grading_rule = {
"description": descr,
}
if due_local_naive is not None:
new_grading_rule["due"] = due_local_naive
new_grading_rule["if_completed_before"] = due_local_naive
for attr_name in ["credit_percent", "bonus_points",
"max_points", "max_points_enforced_cap"]:
if form.cleaned_data[attr_name] is not None:
new_grading_rule[attr_name] = form.cleaned_data[attr_name]
if (form.cleaned_data.get("restrict_to_same_tag")
and session.access_rules_tag is not None):
new_grading_rule["if_has_tag"] = session.access_rules_tag
if hasattr(grading_rule, "generates_grade"):
new_grading_rule["generates_grade"] = \
grading_rule.generates_grade
validate_session_grading_rule(
vctx, ugettext("newly created exception"),
dict_to_struct(new_grading_rule), tags,
grading_rule.grade_identifier)
fre_grading = FlowRuleException(
flow_id=flow_id,
participation=participation,
creator=pctx.request.user,
comment=form.cleaned_data["comment"],
kind=flow_rule_kind.grading,
rule=new_grading_rule)
fre_grading.save()
# }}}
messages.add_message(pctx.request, messages.SUCCESS,
ugettext(
"Exception granted to '%(participation)s' "
"for '%(flow_id)s'.")
% {
'participation': participation,
'flow_id': flow_id})
return redirect(
"relate-grant_exception",
pctx.course.identifier)
else:
data = {
"restrict_to_same_tag": session.access_rules_tag is not None,
"credit_percent": grading_rule.credit_percent,
#"due_same_as_access_expiration": True,
"due": grading_rule.due,
}
for perm in access_rule.permissions:
data[perm] = True
form = ExceptionStage3Form(data, flow_desc, session.access_rules_tag)
return render_course_page(pctx, "course/generic-course-form.html", {
"form": form,
"form_description": ugettext("Grant Exception"),
"form_text": string_concat(
"<div class='well'>",
ugettext("Granting exception to '%(participation)s' "
"for '%(flow_id)s' (session %(session)s)."),
"</div>")
% {
'participation': participation,
'flow_id': flow_id,
'session': strify_session_for_exception(session)},
})
def view_single_grade(pctx, participation_id, opportunity_id):
from course.views import get_now_or_fake_time
now_datetime = get_now_or_fake_time(pctx.request)
participation = get_object_or_404(Participation,
id=int(participation_id))
if participation.course != pctx.course:
raise SuspiciousOperation("participation does not match course")
opportunity = get_object_or_404(GradingOpportunity, id=int(opportunity_id))
if pctx.role in [
participation_role.instructor,
participation_role.teaching_assistant]:
if not opportunity.shown_in_grade_book:
messages.add_message(pctx.request, messages.INFO,
"This grade is not shown in the grade book.")
if not opportunity.shown_in_student_grade_book:
messages.add_message(pctx.request, messages.INFO,
"This grade is not shown in the student grade book.")
elif pctx.role == participation_role.student:
if participation != pctx.participation:
raise PermissionDenied("may not view other people's grades")
if not (opportunity.shown_in_grade_book
and opportunity.shown_in_student_grade_book):
raise PermissionDenied("grade has not been released")
else:
raise PermissionDenied()
# {{{ modify sessions buttons
if pctx.role in [
participation_role.instructor,
participation_role.teaching_assistant]:
allow_session_actions = True
request = pctx.request
if pctx.request.method == "POST":
action_re = re.compile("^([a-z]+)_([0-9]+)$")
for key in request.POST.keys():
action_match = action_re.match(key)
if action_match:
break
if not action_match:
raise SuspiciousOperation("unknown action")
session = FlowSession.objects.get(id=int(action_match.group(2)))
op = action_match.group(1)
from course.flow import (
reopen_session,
regrade_session,
recalculate_session_grade,
expire_flow_session_standalone,
finish_flow_session_standalone)
try:
if op == "expire":
expire_flow_session_standalone(
pctx.repo, pctx.course, session, now_datetime)
messages.add_message(pctx.request, messages.SUCCESS,
"Session expired.")
elif op == "end":
finish_flow_session_standalone(
pctx.repo, pctx.course, session,
now_datetime=now_datetime)
messages.add_message(pctx.request, messages.SUCCESS,
"Session ended.")
elif op == "reopen":
reopen_session(session)
messages.add_message(pctx.request, messages.SUCCESS,
"Session reopened.")
elif op == "regrade":
regrade_session(
pctx.repo, pctx.course, session)
messages.add_message(pctx.request, messages.SUCCESS,
"Session regraded.")
elif op == "recalculate":
recalculate_session_grade(
pctx.repo, pctx.course, session)
messages.add_message(pctx.request, messages.SUCCESS,
"Session grade recalculated.")
else:
raise SuspiciousOperation("invalid session operation")
except Exception as e:
messages.add_message(pctx.request, messages.ERROR,
"Error: %s %s" % (type(e).__name__, str(e)))
else:
allow_session_actions = False
# }}}
grade_changes = list(GradeChange.objects
.filter(
opportunity=opportunity,
participation=participation)
.order_by("grade_time")
.select_related("participation")
.select_related("participation__user")
.select_related("creator")
.select_related("opportunity"))
state_machine = GradeStateMachine()
state_machine.consume(grade_changes, set_is_superseded=True)
flow_grade_aggregation_strategy_text = None
if opportunity.flow_id:
flow_sessions = list(FlowSession.objects
.filter(
participation=participation,
flow_id=opportunity.flow_id,
)
.order_by("start_time"))
from collections import namedtuple
SessionProperties = namedtuple("SessionProperties",
["due", "grade_description"])
from course.utils import get_session_grading_rule
from course.content import get_flow_desc
flow_desc = get_flow_desc(pctx.repo, pctx.course,
opportunity.flow_id, pctx.course_commit_sha)
flow_sessions_and_session_properties = []
for session in flow_sessions:
grading_rule = get_session_grading_rule(
session, pctx.role, flow_desc, now_datetime)
session_properties = SessionProperties(
due=grading_rule.due,
grade_description=grading_rule.description)
flow_sessions_and_session_properties.append(
(session, session_properties))
else:
flow_sessions_and_session_properties = None
return render_course_page(pctx, "course/gradebook-single.html", {
"opportunity": opportunity,
"grade_participation": participation,
"grade_state_change_types": grade_state_change_types,
"grade_changes": grade_changes,
"state_machine": state_machine,
"flow_sessions_and_session_properties": flow_sessions_and_session_properties,
"allow_session_actions": allow_session_actions,
"show_privileged_info": pctx.role in [
participation_role.instructor,
participation_role.teaching_assistant
],
"flow_grade_aggregation_strategy": flow_grade_aggregation_strategy_text,
})
def grade_flow_page(pctx, flow_session_id, page_ordinal):
page_ordinal = int(page_ordinal)
if pctx.role not in [
participation_role.instructor,
participation_role.teaching_assistant]:
raise PermissionDenied(
_("must be instructor or TA to view grades"))
flow_session = get_object_or_404(FlowSession, id=int(flow_session_id))
if flow_session.course.pk != pctx.course.pk:
raise SuspiciousOperation(
_("Flow session not part of specified course"))
if flow_session.participation is None:
raise SuspiciousOperation(
_("Cannot grade anonymous session"))
fpctx = FlowPageContext(pctx.repo, pctx.course, flow_session.flow_id,
page_ordinal, participation=flow_session.participation,
flow_session=flow_session)
if fpctx.page_desc is None:
raise http.Http404()
# {{{ enable flow session zapping
all_flow_sessions = list(FlowSession.objects
.filter(
course=pctx.course,
flow_id=flow_session.flow_id,
participation__isnull=False,
in_progress=flow_session.in_progress)
.order_by(
"participation__user__last_name",
"start_time"))
next_flow_session_id = None
prev_flow_session_id = None
for i, other_flow_session in enumerate(all_flow_sessions):
if other_flow_session.pk == flow_session.pk:
if i > 0:
prev_flow_session_id = all_flow_sessions[i-1].id
if i + 1 < len(all_flow_sessions):
next_flow_session_id = all_flow_sessions[i+1].id
# }}}
# {{{ reproduce student view
form = None
feedback = None
answer_data = None
grade_data = None
most_recent_grade = None
if fpctx.page.expects_answer():
if fpctx.prev_answer_visit is not None:
answer_data = fpctx.prev_answer_visit.answer
most_recent_grade = fpctx.prev_answer_visit.get_most_recent_grade()
if most_recent_grade is not None:
feedback = get_feedback_for_grade(most_recent_grade)
grade_data = most_recent_grade.grade_data
else:
feedback = None
grade_data = None
else:
feedback = None
from course.page.base import PageBehavior
page_behavior = PageBehavior(
show_correctness=True,
show_answer=False,
may_change_answer=False)
form = fpctx.page.make_form(
fpctx.page_context, fpctx.page_data.data,
answer_data, page_behavior)
if form is not None:
form_html = fpctx.page.form_to_html(
pctx.request, fpctx.page_context, form, answer_data)
else:
form_html = None
# }}}
# {{{ grading form
if (fpctx.page.expects_answer()
and fpctx.page.is_answer_gradable()
and fpctx.prev_answer_visit is not None
and not flow_session.in_progress):
request = pctx.request
if pctx.request.method == "POST":
grading_form = fpctx.page.post_grading_form(
fpctx.page_context, fpctx.page_data, grade_data,
request.POST, request.FILES)
if grading_form.is_valid():
grade_data = fpctx.page.update_grade_data_from_grading_form(
fpctx.page_context, fpctx.page_data, grade_data,
grading_form, request.FILES)
feedback = fpctx.page.grade(
fpctx.page_context, fpctx.page_data,
answer_data, grade_data)
if feedback is not None:
correctness = feedback.correctness
else:
correctness = None
if feedback is not None:
feedback_json, bulk_feedback_json = feedback.as_json()
else:
feedback_json = bulk_feedback_json = None
most_recent_grade = FlowPageVisitGrade(
visit=fpctx.prev_answer_visit,
grader=pctx.request.user,
graded_at_git_commit_sha=pctx.course_commit_sha,
grade_data=grade_data,
max_points=fpctx.page.max_points(fpctx.page_data),
correctness=correctness,
feedback=feedback_json)
most_recent_grade.save()
update_bulk_feedback(
fpctx.prev_answer_visit.page_data,
most_recent_grade,
bulk_feedback_json)
grading_rule = get_session_grading_rule(
flow_session, flow_session.participation.role,
fpctx.flow_desc, get_now_or_fake_time(request))
from course.flow import grade_flow_session
grade_flow_session(fpctx, flow_session, grading_rule)
else:
grading_form = fpctx.page.make_grading_form(
fpctx.page_context, fpctx.page_data, grade_data)
else:
grading_form = None
if grading_form is not None:
from crispy_forms.layout import Submit
grading_form.helper.add_input(
Submit(
"submit", _("Submit"),
accesskey="s",
css_class="col-lg-offset-2 relate-grading-save-button"))
grading_form_html = fpctx.page.grading_form_to_html(
pctx.request, fpctx.page_context, grading_form, grade_data)
else:
grading_form_html = None
# }}}
# {{{ compute points_awarded
max_points = None
points_awarded = None
if (fpctx.page.expects_answer()
and fpctx.page.is_answer_gradable()):
max_points = fpctx.page.max_points(fpctx.page_data)
if feedback is not None and feedback.correctness is not None:
points_awarded = max_points * feedback.correctness
# }}}
grading_rule = get_session_grading_rule(
flow_session, flow_session.participation.role,
fpctx.flow_desc, get_now_or_fake_time(pctx.request))
if grading_rule.grade_identifier is not None:
grading_opportunity = get_flow_grading_opportunity(
pctx.course, flow_session.flow_id, fpctx.flow_desc,
grading_rule)
else:
grading_opportunity = None
return render_course_page(
pctx,
"course/grade-flow-page.html",
{
"flow_identifier": fpctx.flow_id,
"flow_session": flow_session,
"flow_desc": fpctx.flow_desc,
"ordinal": fpctx.ordinal,
"page_data": fpctx.page_data,
"body": fpctx.page.body(
fpctx.page_context, fpctx.page_data.data),
"form": form,
"form_html": form_html,
"feedback": feedback,
"max_points": max_points,
"points_awarded": points_awarded,
"most_recent_grade": most_recent_grade,
"grading_opportunity": grading_opportunity,
"prev_flow_session_id": prev_flow_session_id,
"next_flow_session_id": next_flow_session_id,
"grading_form": grading_form,
"grading_form_html": grading_form_html,
})
def grade_flow_page(pctx, flow_session_id, page_ordinal):
now_datetime = get_now_or_fake_time(pctx.request)
page_ordinal = int(page_ordinal)
if pctx.role not in [
participation_role.instructor,
participation_role.teaching_assistant]:
raise PermissionDenied(
_("must be instructor or TA to view grades"))
flow_session = get_object_or_404(FlowSession, id=int(flow_session_id))
if flow_session.course.pk != pctx.course.pk:
raise SuspiciousOperation(
_("Flow session not part of specified course"))
if flow_session.participation is None:
raise SuspiciousOperation(
_("Cannot grade anonymous session"))
fpctx = FlowPageContext(pctx.repo, pctx.course, flow_session.flow_id,
page_ordinal, participation=flow_session.participation,
flow_session=flow_session, request=pctx.request)
if fpctx.page_desc is None:
raise http.Http404()
from course.flow import adjust_flow_session_page_data
adjust_flow_session_page_data(pctx.repo, flow_session,
pctx.course.identifier, fpctx.flow_desc)
# {{{ enable flow session zapping
all_flow_sessions = list(FlowSession.objects
.filter(
course=pctx.course,
flow_id=flow_session.flow_id,
participation__isnull=False,
in_progress=flow_session.in_progress)
.order_by(
# Datatables will default to sorting the user list
# by the first column, which happens to be the username.
# Match that sorting.
"participation__user__username",
"start_time"))
next_flow_session_id = None
prev_flow_session_id = None
for i, other_flow_session in enumerate(all_flow_sessions):
if other_flow_session.pk == flow_session.pk:
if i > 0:
prev_flow_session_id = all_flow_sessions[i-1].id
if i + 1 < len(all_flow_sessions):
next_flow_session_id = all_flow_sessions[i+1].id
# }}}
# {{{ reproduce student view
form = None
feedback = None
answer_data = None
grade_data = None
most_recent_grade = None
if fpctx.page.expects_answer():
if fpctx.prev_answer_visit is not None:
answer_data = fpctx.prev_answer_visit.answer
most_recent_grade = fpctx.prev_answer_visit.get_most_recent_grade()
if most_recent_grade is not None:
feedback = get_feedback_for_grade(most_recent_grade)
grade_data = most_recent_grade.grade_data
else:
feedback = None
grade_data = None
else:
feedback = None
from course.page.base import PageBehavior
page_behavior = PageBehavior(
show_correctness=True,
show_answer=False,
may_change_answer=False)
form = fpctx.page.make_form(
fpctx.page_context, fpctx.page_data.data,
answer_data, page_behavior)
if form is not None:
form_html = fpctx.page.form_to_html(
pctx.request, fpctx.page_context, form, answer_data)
else:
form_html = None
# }}}
# {{{ grading form
if (fpctx.page.expects_answer()
and fpctx.page.is_answer_gradable()
and fpctx.prev_answer_visit is not None
and not flow_session.in_progress):
request = pctx.request
if pctx.request.method == "POST":
grading_form = fpctx.page.post_grading_form(
fpctx.page_context, fpctx.page_data, grade_data,
request.POST, request.FILES)
if grading_form.is_valid():
grade_data = fpctx.page.update_grade_data_from_grading_form(
fpctx.page_context, fpctx.page_data, grade_data,
grading_form, request.FILES)
with translation.override(settings.RELATE_ADMIN_EMAIL_LOCALE):
feedback = fpctx.page.grade(
fpctx.page_context, fpctx.page_data,
answer_data, grade_data)
if feedback is not None:
correctness = feedback.correctness
else:
correctness = None
if feedback is not None:
feedback_json, bulk_feedback_json = feedback.as_json()
else:
feedback_json = bulk_feedback_json = None
most_recent_grade = FlowPageVisitGrade(
visit=fpctx.prev_answer_visit,
grader=pctx.request.user,
graded_at_git_commit_sha=pctx.course_commit_sha,
grade_data=grade_data,
max_points=fpctx.page.max_points(fpctx.page_data),
correctness=correctness,
feedback=feedback_json)
_save_grade(fpctx, flow_session, most_recent_grade,
bulk_feedback_json, now_datetime)
else:
grading_form = fpctx.page.make_grading_form(
fpctx.page_context, fpctx.page_data, grade_data)
else:
grading_form = None
if grading_form is not None:
from crispy_forms.layout import Submit
grading_form.helper.form_class += " relate-grading-form"
grading_form.helper.add_input(
Submit(
"submit", _("Submit"),
accesskey="s",
css_class="relate-grading-save-button"))
grading_form_html = fpctx.page.grading_form_to_html(
pctx.request, fpctx.page_context, grading_form, grade_data)
else:
grading_form_html = None
# }}}
# {{{ compute points_awarded
max_points = None
points_awarded = None
if (fpctx.page.expects_answer()
and fpctx.page.is_answer_gradable()):
max_points = fpctx.page.max_points(fpctx.page_data)
if feedback is not None and feedback.correctness is not None:
points_awarded = max_points * feedback.correctness
# }}}
grading_rule = get_session_grading_rule(
flow_session, flow_session.participation.role,
fpctx.flow_desc, get_now_or_fake_time(pctx.request))
if grading_rule.grade_identifier is not None:
grading_opportunity = get_flow_grading_opportunity(
pctx.course, flow_session.flow_id, fpctx.flow_desc,
grading_rule)
else:
grading_opportunity = None
return render_course_page(
pctx,
"course/grade-flow-page.html",
{
"flow_identifier": fpctx.flow_id,
"flow_session": flow_session,
"flow_desc": fpctx.flow_desc,
"ordinal": fpctx.ordinal,
"page_data": fpctx.page_data,
"body": fpctx.page.body(
fpctx.page_context, fpctx.page_data.data),
"form": form,
"form_html": form_html,
"feedback": feedback,
"max_points": max_points,
"points_awarded": points_awarded,
"most_recent_grade": most_recent_grade,
"grading_opportunity": grading_opportunity,
"prev_flow_session_id": prev_flow_session_id,
"next_flow_session_id": next_flow_session_id,
"grading_form": grading_form,
"grading_form_html": grading_form_html,
"correct_answer": fpctx.page.correct_answer(
fpctx.page_context, fpctx.page_data.data,
answer_data, grade_data),
})
def finish_flow_session_view(pctx, flow_session_id):
now_datetime = get_now_or_fake_time(pctx.request)
request = pctx.request
flow_session_id = int(flow_session_id)
flow_session = get_and_check_flow_session(pctx, flow_session_id)
flow_id = flow_session.flow_id
fctx = FlowContext(pctx.repo, pctx.course, flow_id, participation=pctx.participation, flow_session=flow_session)
access_rule = get_session_access_rule(flow_session, pctx.role, fctx.flow_desc, now_datetime, pctx.remote_address)
answer_visits = assemble_answer_visits(flow_session)
from course.content import markup_to_html
completion_text = markup_to_html(fctx.course, fctx.repo, pctx.course_commit_sha, fctx.flow_desc.completion_text)
(answered_count, unanswered_count) = count_answered_gradable(fctx, flow_session, answer_visits)
is_graded_flow = bool(answered_count + unanswered_count)
if flow_permission.view not in access_rule.permissions:
raise PermissionDenied()
def render_finish_response(template, **kwargs):
render_args = {"flow_identifier": fctx.flow_id, "flow_desc": fctx.flow_desc}
render_args.update(kwargs)
return render_course_page(pctx, template, render_args, allow_instant_flow_requests=False)
if request.method == "POST":
if "submit" not in request.POST:
raise SuspiciousOperation(_("odd POST parameters"))
if not flow_session.in_progress:
raise PermissionDenied(_("Can't end a session that's already ended"))
if flow_permission.end_session not in access_rule.permissions:
raise PermissionDenied(_("not permitted to end session"))
grading_rule = get_session_grading_rule(flow_session, pctx.role, fctx.flow_desc, now_datetime)
grade_info = finish_flow_session(fctx, flow_session, grading_rule, now_datetime=now_datetime)
if is_graded_flow:
return render_finish_response(
"course/flow-completion-grade.html", completion_text=completion_text, grade_info=grade_info
)
else:
return render_finish_response(
"course/flow-completion.html",
last_page_nr=None,
flow_session=flow_session,
completion_text=completion_text,
)
if not is_graded_flow or (flow_session.in_progress and flow_permission.end_session not in access_rule.permissions):
# No ability to end--just show completion page.
return render_finish_response(
"course/flow-completion.html",
last_page_nr=flow_session.page_count - 1,
flow_session=flow_session,
completion_text=completion_text,
)
elif not flow_session.in_progress:
# Just reviewing: re-show grades.
grade_info = gather_grade_info(fctx, flow_session, answer_visits)
return render_finish_response(
"course/flow-completion-grade.html", completion_text=completion_text, grade_info=grade_info
)
else:
# confirm ending flow
return render_finish_response(
"course/flow-confirm-completion.html",
last_page_nr=flow_session.page_count - 1,
flow_session=flow_session,
answered_count=answered_count,
unanswered_count=unanswered_count,
total_count=answered_count + unanswered_count,
)
def get_session_grading_rule_1_day_due_side_effect(
session, flow_desc, now_datetime):
from course.utils import get_session_grading_rule
actual_grading_rule = get_session_grading_rule(session, flow_desc, now_datetime)
actual_grading_rule.due = now() + timedelta(days=1)
return actual_grading_rule
def view_start_flow(pctx, flow_id):
request = pctx.request
now_datetime = get_now_or_fake_time(request)
fctx = FlowContext(pctx.repo, pctx.course, flow_id, participation=pctx.participation)
session_start_rule = get_session_start_rule(
pctx.course,
pctx.participation,
pctx.role,
flow_id,
fctx.flow_desc,
now_datetime,
remote_address=pctx.remote_address,
)
if request.method == "POST":
if "start" in request.POST:
if not session_start_rule.may_start_new_session:
raise PermissionDenied(_("new session not allowed"))
session = start_flow(
pctx.repo,
pctx.course,
pctx.participation,
flow_id,
fctx.flow_desc,
access_rules_tag=session_start_rule.tag_session,
now_datetime=now_datetime,
)
return redirect("relate-view_flow_page", pctx.course.identifier, session.id, 0)
else:
raise SuspiciousOperation(_("unrecognized POST action"))
else:
if session_start_rule.may_list_existing_sessions:
past_sessions = FlowSession.objects.filter(
participation=pctx.participation, flow_id=fctx.flow_id, participation__isnull=False
).order_by("start_time")
from collections import namedtuple
SessionProperties = namedtuple(
"SessionProperties", ["may_view", "may_modify", "due", "grade_description"] # noqa
)
past_sessions_and_properties = []
for session in past_sessions:
access_rule = get_session_access_rule(
session, pctx.role, fctx.flow_desc, now_datetime, remote_address=pctx.remote_address
)
grading_rule = get_session_grading_rule(session, pctx.role, fctx.flow_desc, now_datetime)
session_properties = SessionProperties(
may_view=flow_permission.view in access_rule.permissions,
may_modify=(
flow_permission.submit_answer in access_rule.permissions
or flow_permission.end_session in access_rule.permissions
),
due=grading_rule.due,
grade_description=grading_rule.description,
)
past_sessions_and_properties.append((session, session_properties))
else:
past_sessions_and_properties = []
may_start = session_start_rule.may_start_new_session
potential_session = FlowSession(
course=pctx.course,
participation=pctx.participation,
flow_id=flow_id,
in_progress=True,
expiration_mode=flow_session_expiration_mode.end,
access_rules_tag=session_start_rule.tag_session,
)
new_session_grading_rule = get_session_grading_rule(potential_session, pctx.role, fctx.flow_desc, now_datetime)
start_may_decrease_grade = bool(
past_sessions_and_properties
) and new_session_grading_rule.grade_aggregation_strategy not in [
None,
grade_aggregation_strategy.max_grade,
grade_aggregation_strategy.use_earliest,
]
return render_course_page(
pctx,
"course/flow-start.html",
{
"flow_desc": fctx.flow_desc,
"flow_identifier": flow_id,
"now": now_datetime,
"may_start": may_start,
"new_session_grading_rule": new_session_grading_rule,
"grade_aggregation_strategy_descr": (
dict(GRADE_AGGREGATION_STRATEGY_CHOICES).get(new_session_grading_rule.grade_aggregation_strategy)
),
"start_may_decrease_grade": start_may_decrease_grade,
"past_sessions_and_properties": past_sessions_and_properties,
},
allow_instant_flow_requests=False,
)