def test_announcement_i18n_title(self):
locale = 'de'
announcement = self._add_announcement_and_translation(locale)
actions.login('*****@*****.**')
actions.register(self, 'John Doe')
# Verify that one-off title translation also works.
try:
sites.set_path_info('/' + self.COURSE)
ctx = sites.get_course_for_current_request()
save_locale = ctx.get_current_locale()
key = announcements.TranslatableResourceAnnouncement.key_for_entity(
announcement)
# Untranslated
ctx.set_current_locale(None)
i18n_title = str(
announcements.TranslatableResourceAnnouncement.get_i18n_title(
key))
self.assertEquals('Test Announcement', i18n_title)
# Translated
ctx.set_current_locale(locale)
i18n_title = str(
announcements.TranslatableResourceAnnouncement.get_i18n_title(
key))
self.assertEquals('TEST ANNOUNCEMENT', i18n_title)
finally:
ctx.set_current_locale(save_locale)
sites.unset_path_info()
def SCHEMA_ANNOTATIONS_DICT(cls): # pylint: disable-msg=g-bad-name
"""Schema annotations are dynamic and include a list of courses."""
# Make a list of courses user has the rights to.
course_list = []
for acourse in sites.get_all_courses():
if not roles.Roles.is_course_admin(acourse):
continue
if acourse == sites.get_course_for_current_request():
continue
course_list.append({
'value': acourse.raw,
'label': acourse.get_title()
})
if not course_list:
return None
# Format annotations.
return [(['title'], 'Import Course'),
(['properties', 'course', '_inputex'], {
'label': 'Available Courses',
'_type': 'select',
'choices': course_list
})]
def create_and_configure_jinja_environment(dirs,
autoescape=True,
handler=None,
default_locale='en_US'):
"""Sets up an environment and gets jinja template."""
# Defer to avoid circular import.
from controllers import sites
locale = None
app_context = sites.get_course_for_current_request()
if app_context:
locale = app_context.get_current_locale()
if not locale:
locale = app_context.default_locale
if not locale:
locale = default_locale
jinja_environment = create_jinja_environment(jinja2.FileSystemLoader(dirs),
locale=locale,
autoescape=autoescape)
jinja_environment.filters['gcb_tags'] = get_gcb_tags_filter(handler)
return jinja_environment
def _get_top_nav(self):
current_action = self.request.get('action')
nav = safe_dom.NodeList()
course = sites.get_course_for_current_request()
for action, title in self.nav_mappings:
if action == "gDefier":
if not course.get_slug().split("_")[-1] == "DFR":
continue
class_name = 'selected' if action == current_action else ''
action_href = 'dashboard?action=%s' % action
nav.append(safe_dom.Element(
'a', href=action_href, className=class_name).add_text(
title))
if roles.Roles.is_super_admin():
nav.append(safe_dom.Element(
'a', href='/admin').add_text('Admin'))
nav.append(safe_dom.Element(
'a',
href='https://code.google.com/p/course-builder/wiki/Dashboard',
target='_blank'
).add_text('Help'))
"""--------------- GDEFIER MODIFICATION ------------------------"""
#nav.append(safe_dom.Element(
# 'a', href='gDefier/home',).add_text('G-Defier'))
"""---------------------- END ---------------------------------"""
return nav
def get_template(template_name, dirs, handler=None, autoescape=True):
"""Sets up an environment and gets jinja template."""
# Defer to avoid circular import.
# pylint: disable-msg=g-import-not-at-top
from controllers import sites
locale = None
app_context = sites.get_course_for_current_request()
if app_context:
locale = app_context.get_current_locale()
if not locale:
locale = app_context.default_locale
if not locale:
locale = 'en_US'
jinja_environment = create_jinja_environment(jinja2.FileSystemLoader(dirs),
locale=locale,
autoescape=autoescape)
jinja_environment.filters['gcb_tags'] = get_gcb_tags_filter(handler)
jinja_environment.globals[
'profiler_includes'] = gae_mini_profiler.templatetags.profiler_includes
return jinja_environment.get_template(template_name)
def SCHEMA_ANNOTATIONS_DICT(cls): # pylint: disable-msg=g-bad-name
"""Schema annotations are dynamic and include a list of courses."""
# Make a list of courses user has the rights to.
course_list = []
for acourse in sites.get_all_courses():
if not roles.Roles.is_course_admin(acourse):
continue
if acourse == sites.get_course_for_current_request():
continue
course_list.append({
'value': acourse.raw,
'label': cgi.escape(acourse.get_title())})
if not course_list:
return None
# Format annotations.
return [
(['title'], 'Import Course'),
(
['properties', 'course', '_inputex'],
{
'label': 'Available Courses',
'_type': 'select',
'choices': course_list})]
def test_announcement_i18n_title(self):
locale = 'de'
announcement = self._add_announcement_and_translation(locale)
actions.login('*****@*****.**')
actions.register(self, 'John Doe')
# Verify that one-off title translation also works.
try:
sites.set_path_info('/' + self.COURSE)
ctx = sites.get_course_for_current_request()
save_locale = ctx.get_current_locale()
key = announcements.TranslatableResourceAnnouncement.key_for_entity(
announcement)
# Untranslated
ctx.set_current_locale(None)
i18n_title = str(
announcements.TranslatableResourceAnnouncement.get_i18n_title(
key))
self.assertEquals('Test Announcement', i18n_title)
# Translated
ctx.set_current_locale(locale)
i18n_title = str(
announcements.TranslatableResourceAnnouncement.get_i18n_title(
key))
self.assertEquals('TEST ANNOUNCEMENT', i18n_title)
finally:
ctx.set_current_locale(save_locale)
sites.unset_path_info()
def create_group(self):
course = sites.get_course_for_current_request()
group = GDefierGroup.gql("WHERE name = '" + course.get_namespace_name() + "'").get()
if not group:
print "Creating group..."
aux_group = GDefierGroup(name=course.get_namespace_name()).put()
return aux_group
return group
def render(self, node, unused_handler):
"""Embed just a <script> tag that will in turn create an <iframe>."""
category = node.attrib.get('forum-category')
course = sites.get_course_for_current_request().get_environ()['course']
url = course['VANILLA_EMBED_URL']
return cElementTree.XML("""
<div style='width: 750px;'>
<script>window.location.hash = '/categories/%s';</script><script type="text/javascript" src="//%s/js/embed.js"></script><noscript>Please enable JavaScript to view discussions.</noscript>
</div>""" % (cgi.escape(category), cgi.escape(url)))
def get_i18n_title(cls, resource_key):
locale = None
app_context = sites.get_course_for_current_request()
if (app_context and
app_context.default_locale != app_context.get_current_locale()):
locale = app_context.get_current_locale()
announcements = AnnouncementEntity.get_announcements(locale)
item = common_utils.find(
lambda a: a.key().id() == int(resource_key.key), announcements)
return item.title if item else None
def create_board(self, blocks):
course = sites.get_course_for_current_request()
board = GDefierBoard.gql("WHERE name = '" + course.get_namespace_name() + "'").get()
if not board:
print "Creating board..."
aux_board = GDefierBoard(name=course.get_namespace_name()).put()
for b in blocks:
print "Creating block to board..."
GDefierBoardBlock(blockID=b['block_title'], board=[aux_board]).put()
return aux_board
return board
def _update_global_profile_attributes(
cls,
profile,
email=None,
legal_name=None,
nick_name=None,
date_of_birth=None,
is_enrolled=None,
final_grade=None,
course_info=None,
):
"""Modifies various attributes of Student's Global Profile."""
# TODO(psimakov): update of email does not work for student
if email is not None:
profile.email = email
if legal_name is not None:
profile.legal_name = legal_name
if nick_name is not None:
profile.nick_name = nick_name
if date_of_birth is not None:
profile.date_of_birth = date_of_birth
if not (is_enrolled is None and final_grade is None and course_info is None):
# Defer to avoid circular import.
# pylint: disable-msg=g-import-not-at-top
from controllers import sites
course = sites.get_course_for_current_request()
course_namespace = course.get_namespace_name()
if is_enrolled is not None:
enrollment_dict = transforms.loads(profile.enrollment_info)
enrollment_dict[course_namespace] = is_enrolled
profile.enrollment_info = transforms.dumps(enrollment_dict)
if final_grade is not None or course_info is not None:
course_info_dict = {}
if profile.course_info:
course_info_dict = transforms.loads(profile.course_info)
if course_namespace in course_info_dict.keys():
info = course_info_dict[course_namespace]
else:
info = {}
if final_grade:
info["final_grade"] = final_grade
if course_info:
info["info"] = course_info
course_info_dict[course_namespace] = info
profile.course_info = transforms.dumps(course_info_dict)
def _get_course_list(cls):
# Make a list of courses user has the rights to.
course_list = []
for acourse in sites.get_all_courses():
if not roles.Roles.is_course_admin(acourse):
continue
if acourse == sites.get_course_for_current_request():
continue
course_list.append({
'value': acourse.raw,
'label': cgi.escape(acourse.get_title())})
return course_list
def render(self, node, unused_handler):
"""Embed just a <script> tag that will in turn create an <iframe>."""
category = node.attrib.get('forum-category')
course = sites.get_course_for_current_request().get_environ()['course']
url = course['VANILLA_EMBED_URL']
return cElementTree.XML(
"""
<div id="forum">
<script>window.location.hash = '/categories/%s';</script><script type="text/javascript" src="//%s/js/embed.js"></script><noscript>Please enable JavaScript to view discussions.</noscript>
</div>""" % (
cgi.escape(category), cgi.escape(url)))
def _get_course_list(cls):
# Make a list of courses user has the rights to.
course_list = []
for acourse in sites.get_all_courses():
if not roles.Roles.is_course_admin(acourse):
continue
if acourse == sites.get_course_for_current_request():
continue
course_list.append({
'value': acourse.raw,
'label': cgi.escape(acourse.get_title())
})
return course_list
def _get_course_list(cls):
# Make a list of courses user has the rights to.
course_list = []
for acourse in sites.get_all_courses():
if not roles.Roles.is_course_admin(acourse):
continue
if acourse == sites.get_course_for_current_request():
continue
atitle = "%s (%s)" % (acourse.get_title(), acourse.get_slug())
course_list.append({"value": acourse.raw, "label": cgi.escape(atitle)})
return course_list
def get_gDefier(self):
"""Renders course indexing view if G-Defier module is enabled."""
template_values = {}
mc_template_value = {}
course = sites.get_course_for_current_request()
template_values['page_title'] = self.format_title('GDefier')
""" Catching url hackers """
if not course.get_slug().split("_")[-1] == "DFR":
mc_template_value['is_dashboard'] = True
mc_template_value['error_code'] = 'disabled_gDefier_module'
template_values['main_content'] = jinja2.Markup(self.get_template(
'templates/gDefier_error.html', [os.path.dirname(__file__)]
).render(mc_template_value, autoescape=True))
self.render_page(template_values)
return
gDefier_actions = []
# Enable editing if supported.
if filer.is_editable_fs(self.app_context):
gDefier_actions.append({
'id': 'edit_gDefier_DB',
'caption': 'Edit',
'action': self.get_action_url('edit_gDefier_course_settings'),
'xsrf_token': self.create_xsrf_token(
'edit_gDefier_course_settings')})
# gDefier.yaml file content.
gDefier_info = []
yaml_stream = self.app_context.fs.open(get_gDefier_config_filename(self))
if yaml_stream:
yaml_lines = yaml_stream.read().decode('utf-8')
for line in yaml_lines.split('\n'):
gDefier_info.append(line)
else:
gDefier_info.append('< empty file >')
# Prepare template values.
template_values['sections'] = [
{
'title': 'Contents of DATA table from gDefier DB',
'description': "General settings for G-Defier Module to this course.",
'actions': gDefier_actions,
'children': gDefier_info}]
self.render_page(template_values)
def _update_global_profile_attributes(cls,
profile,
email=None,
legal_name=None,
nick_name=None,
date_of_birth=None,
is_enrolled=None,
final_grade=None,
course_info=None):
"""Modifies various attributes of Student's Global Profile."""
# TODO(psimakov): update of email does not work for student
if email is not None:
profile.email = email
if legal_name is not None:
profile.legal_name = legal_name
if nick_name is not None:
profile.nick_name = nick_name
if date_of_birth is not None:
profile.date_of_birth = date_of_birth
if not (is_enrolled is None and final_grade is None
and course_info is None):
# Defer to avoid circular import.
# pylint: disable-msg=g-import-not-at-top
from controllers import sites
course = sites.get_course_for_current_request()
course_namespace = course.get_namespace_name()
if is_enrolled is not None:
enrollment_dict = transforms.loads(profile.enrollment_info)
enrollment_dict[course_namespace] = is_enrolled
profile.enrollment_info = transforms.dumps(enrollment_dict)
if final_grade is not None or course_info is not None:
course_info_dict = {}
if profile.course_info:
course_info_dict = transforms.loads(profile.course_info)
if course_namespace in course_info_dict.keys():
info = course_info_dict[course_namespace]
else:
info = {}
if final_grade:
info['final_grade'] = final_grade
if course_info:
info['info'] = course_info
course_info_dict[course_namespace] = info
profile.course_info = transforms.dumps(course_info_dict)
def _translate_content(cls, items):
app_context = sites.get_course_for_current_request()
course = courses.Course.get(app_context)
key_list = [
TranslatableResourceAnnouncement.key_for_entity(item)
for item in items]
FakeDto = collections.namedtuple('FakeDto', ['dict'])
fake_items = [
FakeDto({'title': item.title, 'html': item.html})
for item in items]
i18n_dashboard.translate_dto_list(course, fake_items, key_list)
for item, fake_item in zip(items, fake_items):
item.title = str(fake_item.dict['title'])
item.html = str(fake_item.dict['html'])
def create_player(self):
nick = self.get_user().nickname()
alumn = GDefierPlayer.gql("WHERE name = '" + nick +"'").get()
if not alumn:
print "user created"
#Creating and adding to correspondent group
course = sites.get_course_for_current_request()
aux_group = GDefierGroup.gql("WHERE name = '" + course.get_namespace_name() + "'").get()
if not aux_group:
print "First player..."
aux_group = create_group(self)
else:
aux_group=aux_group.key()
GDefierPlayer(name=nick, group=[aux_group]).put()
def get(self):
"""Handles GET requests."""
if not self.personalize_page_and_get_enrolled():
return
path = sites.abspath(self.app_context.get_home_folder(),
GCB_GDEFIER_FOLDER_NAME)
course = sites.get_course_for_current_request()
if not course.get_slug().split("_")[-1] == "DFR":
page = 'templates/gDefier_error.html'
self.template_value['error_code'] = 'disabled_gDefier_module'
self.template_value['is_dashboard'] = False
else:
page = 'templates/gDefier.html'
# Patch to double apparition of registration
registration = None
if gDefier_model.player_has_blocks(self):
if self.request.get('registered')=='yes':
registration = False
else:
registration = True
else:
registration = False
entity = get_course_dict()
player = gDefier_model.get_player(self)
prctng = []
for b in player.blocks:
n = int(b.wins*100/entity['module']['n_defies'])
for i in range(entity['module']['blocks'].__len__()):
if entity['module']['blocks'][i]["block_title"]==b.blockID:
prctng.insert(i, "n"+str(n))
noprctng = prctng
noprctng = map(lambda s: s.strip('n'), noprctng)
print noprctng
template = self.get_template(page, additional_dirs=[path])
self.template_value['gDefier_transient_student'] = registration
self.template_value['navbar'] = {'gDefier': True}
self.template_value['entity'] = entity
self.template_value['player'] = player
self.template_value['prctng'] = prctng
self.template_value['noprctng'] = noprctng
self.render(template)
def check_personalization(browser, response):
"""Checks that the login/logout text is correct."""
sites.set_path_info(browser.last_request_url)
app_context = sites.get_course_for_current_request()
sites.unset_path_info()
browsable = app_context.get_environ()['course']['browsable']
if browsable:
callbacks = [
functools.partial(check_login_link, response.body),
functools.partial(check_logout_link, response.body)
]
assert_at_least_one_succeeds(callbacks)
else:
check_logout_link(response.body)
def __init__(self, request, response): # pylint: disable=super-init-not-called
self.initialize(request, response)
# Check to see if the current user is admin
self.is_admin = users.is_current_user_admin()
# Store the original namespace, before setting the course specific one.
self.old_namespace = namespace_manager.get_namespace()
# Set the active namespace to the course domain namespace
try:
sites.set_path_info(self.request.path, self.request.server_name)
except AttributeError as e:
logging.error(e)
namespace = namespace_manager.get_namespace()
if namespace:
self.app_context = sites.get_course_for_current_request()
self.is_admin = roles.Roles.is_course_admin(self.app_context)
is_public = self.app_context.now_available
if self.is_admin is False and is_public is False:
# if course is private, and user has not logged in, redirect to login
# else if user is logged in and not admin, 404
if not users.get_current_user():
self.redirect(users.create_login_url(self.request.path))
else:
self.abort(404)
# Set the current user with their preferences
self.student = StudentSvc.get_current_student()
if self.student:
self.student.prefs = StudentSvc.get_current_user_preferences()
if self.current_user:
self._xsrf_token = xsrf.GenerateToken(_GetXsrfKey(),
self.current_user.email())
self.response.set_cookie('XSRF-TOKEN', self._xsrf_token, httponly=False)
else:
self._xsrf_token = None
self._RawWrite = self.response.out.write
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
# Set the active locale
self.locale_key = LocaleSvc.get_locale_key('en_GB')
def get_course_picker(self, destination=None):
destination = destination or '/dashboard'
action = self.request.get('action') or self._default_get_action
# disable picker if we are on the well known page; we dont want picked
# on pages where edits or creation of new object can get triggered
safe_action = action and action in [
a for a, _ in self.get_nav_mappings()
] + ['admin']
tab = self.request.get('tab')
if action in self.get_actions:
tab_group = tabs.Registry.get_tab_group(action)
if tab_group and tab in tab_group:
tab = '&tab=%s' % tab
else:
tab = ''
destination = '%s?action=%s%s' % (destination, action, tab)
current_course = sites.get_course_for_current_request()
options = []
for course in sorted(sites.get_all_courses()):
with Namespace(course.namespace):
if self.current_user_has_access(course):
url = (course.canonicalize_url(destination)
if safe_action else 'javascript:void(0)')
title = '%s (%s)' % (course.get_title(), course.get_slug())
option = safe_dom.Element('li')
link = safe_dom.A(url).add_text(title)
if current_course == course:
link.set_attribute('class', 'selected')
option.add_child(link)
options.append((course.get_title(), option))
picker_class_name = 'hidden'
if not safe_action:
picker_class_name += ' disabled'
picker = safe_dom.Element('ol',
id='gcb-course-picker-menu',
className=picker_class_name)
for title, option in sorted(options, key=lambda item: item[0].lower()):
picker.append(option)
return picker
def get_course_picker(self, destination=None):
destination = destination or '/dashboard'
action = self.request.get('action') or self._default_get_action
# disable picker if we are on the well known page; we dont want picked
# on pages where edits or creation of new object can get triggered
safe_action = action and action in [
a for a, _ in self.get_nav_mappings()] + ['admin']
tab = self.request.get('tab')
if action in self.get_actions:
tab_group = tabs.Registry.get_tab_group(action)
if tab_group and tab in tab_group:
tab = '&tab=%s' % tab
else:
tab = ''
destination = '%s?action=%s%s' % (destination, action, tab)
current_course = sites.get_course_for_current_request()
options = []
for course in sorted(sites.get_all_courses()):
with Namespace(course.namespace):
if self.current_user_has_access(course):
url = (
course.canonicalize_url(destination) if safe_action
else 'javascript:void(0)')
title = '%s (%s)' % (course.get_title(), course.get_slug())
option = safe_dom.Element('li')
link = safe_dom.A(url).add_text(title)
if current_course == course:
link.set_attribute('class', 'selected')
option.add_child(link)
options.append((course.get_title(), option))
picker_class_name = 'hidden'
if not safe_action:
picker_class_name += ' disabled'
picker = safe_dom.Element(
'ol', id='gcb-course-picker-menu', className=picker_class_name)
for title, option in sorted(
options, key=lambda item: item[0].lower()):
picker.append(option)
return picker
def render(self, node, handler):
"""Embed just a <script> tag that will in turn create an <iframe>."""
userinfo = users.get_current_user()
if not userinfo:
return ""
url = node.attrib.get('url')
user = users.get_current_user()
info = sites.get_course_for_current_request().get_environ()
course = info['course']['MOOC_ADMIN_COURSE_ID']
salt = utils.XSRF_SECRET.value
hashed_user = hashlib.sha1( salt + user.user_id() ).hexdigest()
lessonid = handler.lesson_id
height = node.attrib.get('height')
query = node.attrib.get('query')
return cElementTree.XML(
"""
<div style='width: 775px;'>
<iframe src="%s?%s&user=%s&hashed_user=%s&lessonid=%s&course=%s" frameborder="0" width="775" height="%s" style="overflow:hidden"></iframe>
</div>""" % (
cgi.escape(url), cgi.escape(query), cgi.escape(user.user_id()), cgi.escape(hashed_user), lessonid, course, cgi.escape(height)))
def get_template(
template_name, dirs, autoescape=True, handler=None, default_locale='en_US'):
"""Sets up an environment and gets jinja template."""
# Defer to avoid circular import.
from controllers import sites
locale = None
app_context = sites.get_course_for_current_request()
if app_context:
locale = app_context.get_current_locale()
if not locale:
locale = app_context.default_locale
if not locale:
locale = default_locale
jinja_environment = create_jinja_environment(
jinja2.FileSystemLoader(dirs), locale=locale, autoescape=autoescape)
jinja_environment.filters['gcb_tags'] = get_gcb_tags_filter(handler)
return jinja_environment.get_template(template_name)
def SCHEMA_ANNOTATIONS_DICT(cls): # pylint: disable-msg=g-bad-name
"""Schema annotations are dynamic and include a list of courses."""
# Make a list of courses user has the rights to.
course_list = []
for acourse in sites.get_all_courses():
if not roles.Roles.is_course_admin(acourse):
continue
if acourse == sites.get_course_for_current_request():
continue
course_list.append({"value": acourse.raw, "label": acourse.get_title()})
if not course_list:
return None
# Format annotations.
return [
(["title"], "Import Course"),
(
["properties", "course", "_inputex"],
{"label": "Available Courses", "_type": "select", "choices": course_list},
),
]
def get_players(self):
course = sites.get_course_for_current_request().get_namespace_name()
results = db.GqlQuery("SELECT * FROM GDefierGroup WHERE name ='"+course+"'")
for x in results:
players = x.members
return players
