def validate(self, new_page_source):
from relate.utils import dict_to_struct
import yaml
try:
page_desc = dict_to_struct(yaml.safe_load(new_page_source))
from course.validation import (
validate_flow_page, ValidationContext)
vctx = ValidationContext(
# FIXME
repo=None,
commit_sha=None)
validate_flow_page(vctx, "submitted page", page_desc)
if page_desc.type != self.validator_desc.page_type:
raise ValidationError(ugettext("page must be of type '%s'")
% self.validator_desc.page_type)
except Exception:
tp, e, _ = sys.exc_info()
raise forms.ValidationError("%(err_type)s: %(err_str)s"
% {"err_type": tp.__name__, "err_str": str(e)})
def clean(self):
if (self.kind == flow_rule_kind.grading
and self.expiration is not None):
raise ValidationError("grading rules may not expire")
from course.validation import (ValidationError as
ContentValidationError,
validate_session_start_rule,
validate_session_access_rule,
validate_session_grading_rule,
ValidationContext)
from course.content import (get_course_repo, get_course_commit_sha,
get_flow_desc)
from relate.utils import dict_to_struct
rule = dict_to_struct(self.rule)
repo = get_course_repo(self.participation.course)
commit_sha = get_course_commit_sha(self.participation.course,
self.participation)
ctx = ValidationContext(repo=repo, commit_sha=commit_sha)
flow_desc = get_flow_desc(repo, self.participation.course,
self.flow_id, commit_sha)
tags = None
if hasattr(flow_desc, "rules"):
tags = getattr(flow_desc.rules, "tags", None)
try:
if self.kind == flow_rule_kind.start:
validate_session_start_rule(ctx, unicode(self), rule, tags)
elif self.kind == flow_rule_kind.access:
validate_session_access_rule(ctx, unicode(self), rule, tags)
elif self.kind == flow_rule_kind.grading:
validate_session_grading_rule(ctx, unicode(self), rule, tags)
else:
raise ValidationError("invalid rule kind: " + self.kind)
except ContentValidationError as e:
raise ValidationError("invalid existing_session_rules: " + str(e))
def validate(self, new_page_source):
from relate.utils import dict_to_struct
import yaml
try:
page_desc = dict_to_struct(yaml.load(new_page_source))
from course.validation import validate_flow_page, ValidationContext
vctx = ValidationContext(
# FIXME
repo=None,
commit_sha=None)
validate_flow_page(vctx, "submitted page", page_desc)
if page_desc.type != self.validator_desc.page_type:
raise ValidationError("page must be of type '%s'" %
self.validator_desc.page_type)
except:
import sys
tp, e, _ = sys.exc_info()
raise forms.ValidationError("%s: %s" % (tp.__name__, str(e)))
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 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):
from relate.utils import dict_to_struct
import yaml
PAGE_SESSION_KEY = "cf_validated_sandbox_page:" + pctx.course.identifier
ANSWER_DATA_SESSION_KEY = "cf_page_sandbox_answer_data:" + pctx.course.identifier
request = pctx.request
page_source = pctx.request.session.get(PAGE_SESSION_KEY)
page_errors = None
is_preview_post = (request.method == "POST" and "preview" in request.POST)
def make_form(data=None):
return SandboxForm(
page_source, "yaml", vim_mode,
"Enter YAML markup for a flow page.",
data)
vim_mode = pctx.request.session.get(CF_SANDBOX_VIM_MODE, False)
if is_preview_post:
edit_form = make_form(pctx.request.POST)
if edit_form.is_valid():
pctx.request.session[CF_SANDBOX_VIM_MODE] = \
vim_mode = edit_form.cleaned_data["vim_mode"]
try:
new_page_source = edit_form.cleaned_data["content"]
page_desc = dict_to_struct(yaml.load(new_page_source))
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)
except:
import sys
tp, e, _ = sys.exc_info()
page_errors = (
"Page failed to load/validate: "
"%s: %s" % (tp.__name__, 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
page = instantiate_flow_page("sandbox", pctx.repo, page_desc,
pctx.course_commit_sha)
page_data = page.make_page_data()
from course.page import PageContext
page_context = PageContext(
course=pctx.course,
repo=pctx.repo,
commit_sha=pctx.course_commit_sha,
flow_session=None)
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) == 2):
stored_answer_data_page_id, stored_answer_data = \
stored_answer_data_tuple
if stored_answer_data_page_id == page_desc.id:
answer_data = stored_answer_data
# }}}
feedback = None
page_form_html = None
if page.expects_answer():
if request.method == "POST" and not is_preview_post:
page_form = page.post_form(page_context, page_data,
request.POST, request.FILES)
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.id, answer_data)
else:
page_form = page.make_form(page_context, page_data,
answer_data, answer_is_final=False)
if page_form is not None:
page_form.helper.add_input(
Submit("submit", "Submit answer", accesskey="g",
css_class="col-lg-offset-2"))
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,
"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,
})
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 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),
})
