def test_page_behavior_backward_compatibility(self):
answer_is_final = PageBehavior(show_correctness=False, show_answer=False,
may_change_answer=False)
if not answer_is_final:
self.fail(
"PageBehavior object expected to be True "
"when may_change_answer is False for backward "
"compatibility")
answer_is_final = PageBehavior(show_correctness=False, show_answer=False,
may_change_answer=True)
if answer_is_final:
self.fail(
"PageBehavior object expected to be False "
"when may_change_answer is True for backward "
"compatibility")
def view_page_sandbox(pctx):
# type: (CoursePageContext) -> http.HttpResponse
if not pctx.has_permission(pperm.use_page_sandbox):
raise PermissionDenied()
from course.validation import ValidationError
from relate.utils import dict_to_struct, Struct
import yaml
PAGE_SESSION_KEY = make_sandbox_session_key( # noqa
PAGE_SESSION_KEY_PREFIX, pctx.course.identifier)
ANSWER_DATA_SESSION_KEY = make_sandbox_session_key( # noqa
ANSWER_DATA_SESSION_KEY_PREFIX, pctx.course.identifier)
PAGE_DATA_SESSION_KEY = make_sandbox_session_key( # noqa
PAGE_DATA_SESSION_KEY_PREFIX, pctx.course.identifier)
request = pctx.request
page_source = pctx.request.session.get(PAGE_SESSION_KEY)
page_errors = None
page_warnings = None
is_clear_post = (request.method == "POST" and "clear" in request.POST)
is_clear_response_post = (request.method == "POST"
and "clear_response" in request.POST)
is_preview_post = (request.method == "POST" and "preview" in request.POST)
def make_form(data=None):
# type: (Optional[Text]) -> PageSandboxForm
return PageSandboxForm(page_source, "yaml", request.user.editor_mode,
ugettext("Enter YAML markup for a flow page."),
data)
if is_preview_post:
edit_form = make_form(pctx.request.POST)
new_page_source = None
if edit_form.is_valid():
try:
from pytools.py_codegen import remove_common_indentation
new_page_source = remove_common_indentation(
edit_form.cleaned_data["content"],
require_leading_newline=False)
from course.content import expand_yaml_macros
new_page_source = expand_yaml_macros(pctx.repo,
pctx.course_commit_sha,
new_page_source)
yaml_data = yaml.load(new_page_source) # type: ignore
page_desc = dict_to_struct(yaml_data)
if not isinstance(page_desc, Struct):
raise ValidationError(
"Provided page source code is not "
"a dictionary. Do you need to remove a leading "
"list marker ('-') or some stray indentation?")
from course.validation import validate_flow_page, ValidationContext
vctx = ValidationContext(repo=pctx.repo,
commit_sha=pctx.course_commit_sha)
validate_flow_page(vctx, "sandbox", page_desc)
page_warnings = vctx.warnings
except Exception:
import sys
tp, e, _ = sys.exc_info()
page_errors = (ugettext("Page failed to load/validate") +
": " + "%(err_type)s: %(err_str)s" % {
"err_type": tp.__name__,
"err_str": e
}) # type: ignore
else:
# Yay, it did validate.
request.session[
PAGE_SESSION_KEY] = page_source = new_page_source
del new_page_source
edit_form = make_form(pctx.request.POST)
elif is_clear_post:
page_source = None
pctx.request.session[PAGE_DATA_SESSION_KEY] = None
pctx.request.session[ANSWER_DATA_SESSION_KEY] = None
del pctx.request.session[PAGE_DATA_SESSION_KEY]
del pctx.request.session[ANSWER_DATA_SESSION_KEY]
edit_form = make_form()
elif is_clear_response_post:
page_source = None
pctx.request.session[PAGE_DATA_SESSION_KEY] = None
pctx.request.session[ANSWER_DATA_SESSION_KEY] = None
del pctx.request.session[PAGE_DATA_SESSION_KEY]
del pctx.request.session[ANSWER_DATA_SESSION_KEY]
edit_form = make_form(pctx.request.POST)
else:
edit_form = make_form()
have_valid_page = page_source is not None
if have_valid_page:
yaml_data = yaml.load(page_source) # type: ignore
page_desc = cast(FlowPageDesc, dict_to_struct(yaml_data))
from course.content import instantiate_flow_page
try:
page = instantiate_flow_page("sandbox", pctx.repo, page_desc,
pctx.course_commit_sha)
except Exception:
import sys
tp, e, _ = sys.exc_info()
page_errors = (ugettext("Page failed to load/validate") + ": " +
"%(err_type)s: %(err_str)s" % {
"err_type": tp.__name__,
"err_str": e
}) # type: ignore
have_valid_page = False
if have_valid_page:
page_desc = cast(FlowPageDesc, page_desc)
# Try to recover page_data, answer_data
page_data = get_sandbox_data_for_page(pctx, page_desc,
PAGE_DATA_SESSION_KEY)
answer_data = get_sandbox_data_for_page(pctx, page_desc,
ANSWER_DATA_SESSION_KEY)
from course.models import FlowSession
from course.page import PageContext
page_context = PageContext(
course=pctx.course,
repo=pctx.repo,
commit_sha=pctx.course_commit_sha,
# This helps code pages retrieve the editor pref.
flow_session=FlowSession(course=pctx.course,
participation=pctx.participation),
in_sandbox=True)
if page_data is None:
page_data = page.initialize_page_data(page_context)
pctx.request.session[PAGE_DATA_SESSION_KEY] = (page_desc.type,
page_desc.id,
page_data)
title = page.title(page_context, page_data)
body = page.body(page_context, page_data)
feedback = None
page_form_html = None
if page.expects_answer():
from course.page.base import PageBehavior
page_behavior = PageBehavior(show_correctness=True,
show_answer=True,
may_change_answer=True)
if request.method == "POST" and not is_preview_post:
page_form = page.process_form_post(page_context, page_data,
request.POST, request.FILES,
page_behavior)
if page_form.is_valid():
answer_data = page.answer_data(page_context, page_data,
page_form, request.FILES)
feedback = page.grade(page_context,
page_data,
answer_data,
grade_data=None)
pctx.request.session[ANSWER_DATA_SESSION_KEY] = (
page_desc.type, page_desc.id, answer_data)
else:
try:
page_form = page.make_form(page_context, page_data,
answer_data, page_behavior)
except Exception:
import sys
tp, e, _ = sys.exc_info()
page_errors = (
ugettext("Page failed to load/validate "
"(change page ID to clear faults)") + ": " +
"%(err_type)s: %(err_str)s" % {
"err_type": tp.__name__,
"err_str": e
}) # type: ignore # noqa: E501
have_valid_page = False
page_form = None
if page_form is not None:
page_form.helper.add_input(
Submit("submit", ugettext("Submit answer"), accesskey="g"))
page_form_html = page.form_to_html(pctx.request, page_context,
page_form, answer_data)
correct_answer = page.correct_answer(page_context,
page_data,
answer_data,
grade_data=None)
return render_course_page(
pctx,
"course/sandbox-page.html",
{
"edit_form": edit_form,
"page_errors": page_errors,
"page_warnings": page_warnings,
"form": edit_form, # to placate form.media
"have_valid_page": True,
"title": title,
"body": body,
"page_form_html": page_form_html,
"feedback": feedback,
"correct_answer": correct_answer,
})
else:
return render_course_page(
pctx,
"course/sandbox-page.html",
{
"edit_form": edit_form,
"form": edit_form, # to placate form.media
"have_valid_page": False,
"page_errors": page_errors,
"page_warnings": page_warnings,
})
def view_page_sandbox(pctx):
if pctx.role not in [
participation_role.instructor,
participation_role.teaching_assistant]:
raise PermissionDenied(
ugettext("must be instructor or TA to access sandbox"))
from course.validation import ValidationError
from relate.utils import dict_to_struct, Struct
import yaml
PAGE_SESSION_KEY = ( # noqa
"cf_validated_sandbox_page:" + pctx.course.identifier)
ANSWER_DATA_SESSION_KEY = ( # noqa
"cf_page_sandbox_answer_data:" + pctx.course.identifier)
request = pctx.request
page_source = pctx.request.session.get(PAGE_SESSION_KEY)
page_errors = None
page_warnings = None
is_preview_post = (request.method == "POST" and "preview" in request.POST)
from course.models import get_user_status
ustatus = get_user_status(request.user)
def make_form(data=None):
return SandboxForm(
page_source, "yaml", ustatus.editor_mode,
ugettext("Enter YAML markup for a flow page."),
data)
if is_preview_post:
edit_form = make_form(pctx.request.POST)
if edit_form.is_valid():
try:
new_page_source = edit_form.cleaned_data["content"]
page_desc = dict_to_struct(yaml.load(new_page_source))
if not isinstance(page_desc, Struct):
raise ValidationError("Provided page source code is not "
"a dictionary. Do you need to remove a leading "
"list marker ('-') or some stray indentation?")
from course.validation import validate_flow_page, ValidationContext
vctx = ValidationContext(
repo=pctx.repo,
commit_sha=pctx.course_commit_sha)
validate_flow_page(vctx, "sandbox", page_desc)
page_warnings = vctx.warnings
except:
import sys
tp, e, _ = sys.exc_info()
page_errors = (
ugettext("Page failed to load/validate")
+ ": "
+ "%(err_type)s: %(err_str)s" % {
"err_type": tp.__name__, "err_str": e})
else:
# Yay, it did validate.
request.session[PAGE_SESSION_KEY] = page_source = new_page_source
del new_page_source
edit_form = make_form(pctx.request.POST)
else:
edit_form = make_form()
have_valid_page = page_source is not None
if have_valid_page:
page_desc = dict_to_struct(yaml.load(page_source))
from course.content import instantiate_flow_page
try:
page = instantiate_flow_page("sandbox", pctx.repo, page_desc,
pctx.course_commit_sha)
except:
import sys
tp, e, _ = sys.exc_info()
page_errors = (
ugettext("Page failed to load/validate")
+ ": "
+ "%(err_type)s: %(err_str)s" % {
"err_type": tp.__name__, "err_str": e})
have_valid_page = False
if have_valid_page:
page_data = page.make_page_data()
from course.models import FlowSession
from course.page import PageContext
page_context = PageContext(
course=pctx.course,
repo=pctx.repo,
commit_sha=pctx.course_commit_sha,
# This helps code pages retrieve the editor pref.
flow_session=FlowSession(
course=pctx.course,
participation=pctx.participation),
in_sandbox=True)
title = page.title(page_context, page_data)
body = page.body(page_context, page_data)
# {{{ try to recover answer_data
answer_data = None
stored_answer_data_tuple = \
pctx.request.session.get(ANSWER_DATA_SESSION_KEY)
# Session storage uses JSON and may turn tuples into lists.
if (isinstance(stored_answer_data_tuple, (list, tuple))
and len(stored_answer_data_tuple) == 3):
stored_answer_data_page_type, stored_answer_data_page_id, stored_answer_data = \
stored_answer_data_tuple
if (
stored_answer_data_page_type == page_desc.type
and
stored_answer_data_page_id == page_desc.id):
answer_data = stored_answer_data
# }}}
feedback = None
page_form_html = None
if page.expects_answer():
from course.page.base import PageBehavior
page_behavior = PageBehavior(
show_correctness=True,
show_answer=True,
may_change_answer=True)
if request.method == "POST" and not is_preview_post:
page_form = page.process_form_post(page_context, page_data,
request.POST, request.FILES,
page_behavior)
if page_form.is_valid():
answer_data = page.answer_data(page_context, page_data,
page_form, request.FILES)
feedback = page.grade(page_context, page_data, answer_data,
grade_data=None)
pctx.request.session[ANSWER_DATA_SESSION_KEY] = (
page_desc.type, page_desc.id, answer_data)
else:
page_form = page.make_form(page_context, page_data,
answer_data, page_behavior)
if page_form is not None:
page_form.helper.add_input(
Submit("submit",
ugettext("Submit answer"),
accesskey="g"))
page_form_html = page.form_to_html(
pctx.request, page_context, page_form, answer_data)
correct_answer = page.correct_answer(
page_context, page_data, answer_data,
grade_data=None)
return render_course_page(pctx, "course/sandbox-page.html", {
"edit_form": edit_form,
"page_errors": page_errors,
"page_warnings": page_warnings,
"form": edit_form, # to placate form.media
"have_valid_page": True,
"title": title,
"body": body,
"page_form_html": page_form_html,
"feedback": feedback,
"correct_answer": correct_answer,
})
else:
return render_course_page(pctx, "course/sandbox-page.html", {
"edit_form": edit_form,
"form": edit_form, # to placate form.media
"have_valid_page": False,
"page_errors": page_errors,
"page_warnings": page_warnings,
})
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 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,
})