def decorated_f(request, translation_project, *args, **kwargs):
# For now, all permissions in a translation project are
# relative to the root of that translation project.
request.permissions = get_matching_permissions(
get_profile(request.user), translation_project.directory)
request.translation_project = translation_project
return f(request, translation_project, *args, **kwargs)
def GET(self, template_vars, request, translation_project, directory):
template_vars = super(TPTranslateView,
self).GET(template_vars, request)
request.permissions = get_matching_permissions(
get_profile(request.user), translation_project.directory)
project = translation_project.project
language = translation_project.language
template_vars.update({
'translation_project':
translation_project,
'project':
project,
'language':
language,
'directory':
directory,
'children':
get_children(request,
translation_project,
directory,
links_required='translate'),
'navitems': [
navbar_dict.make_directory_navbar_dict(
request, directory, links_required='translate')
],
'feed_path':
directory.pootle_path[1:],
'topstats':
gentopstats_translation_project(translation_project),
})
return template_vars
def test_panel_language_table(language0, rf, member):
request = rf.get("/language0/")
request.user = member
request.permissions = get_matching_permissions(request.user, language0.directory)
view = LanguageBrowseView(kwargs=dict(language_code=language0.code))
view.request = request
view.object = view.get_object()
lang_panels = panels.gather(LanguageBrowseView)
assert lang_panels.keys() == ["children"]
assert lang_panels["children"] == ChildrenPanel
panel = ChildrenPanel(view)
assert panel.panel_name == "children"
assert panel.cache_key == ("panel.%s.%s" % (panel.panel_name, view.cache_key))
table = {
"id": view.view_name,
"fields": panel.table_fields,
"headings": get_table_headings(panel.table_fields),
"rows": view.object_children,
}
assert panel.table == table
assert panel.get_context_data() == dict(table=table, can_translate=view.can_translate)
content = loader.render_to_string(panel.template_name, context=panel.get_context_data())
assert panel.content == panel.update_times(content)
def GET(self, template_vars, request, translation_project, directory):
template_vars = super(ProjectIndexView,
self).GET(template_vars, request)
request.permissions = get_matching_permissions(
get_profile(request.user), translation_project.directory)
state = dispatch.ProjectIndexState(request.GET)
project = translation_project.project
language = translation_project.language
template_vars.update({
'translation_project':
translation_project,
'project':
project,
'language':
language,
'directory':
directory,
'children':
get_children(request, translation_project, directory),
'navitems':
[navbar_dict.make_directory_navbar_dict(request, directory)],
'stats_headings':
get_stats_headings(),
'editing':
state.editing,
'topstats':
gentopstats_translation_project(translation_project),
'feed_path':
directory.pootle_path[1:],
})
return template_vars
def view(request):
request.permissions = get_matching_permissions(get_profile(request.user), Directory.objects.root)
topstats = gentopstats_root()
templatevars = {
'description': pagelayout.get_description(),
'keywords': [
'Pootle',
'translate',
'translation',
'localisation',
'localization',
'l10n',
'traduction',
'traduire',
],
'languagelink': _('Languages'),
'languages': getlanguages(request),
'projectlink': _('Projects'),
'projects': getprojects(request),
'projectstypo3typo3core': getprojectstypo3typo3core(request),
'projectstypo3typo3ext': getprojectstypo3typo3ext(request),
'topstats': topstats,
'instancetitle': pagelayout.get_title(),
'translationlegend': {'translated': _('Translations are complete'),
'fuzzy': _('Translations need to be checked (they are marked fuzzy)'),
'untranslated': _('Untranslated')},
'permissions': request.permissions,
}
visible_langs = [l for l in templatevars['languages'] if l['total'] != 0]
templatevars['moreprojects'] = len(templatevars['projects']) >\
len(visible_langs)
return render_to_response('index/index.html', templatevars, RequestContext(request))
def test_panel_tp_subdir_table(subdir0, rf, member):
request = rf.get(subdir0.pootle_path)
request.user = member
request.permissions = get_matching_permissions(
request.user,
subdir0)
view = TPBrowseView(
kwargs=dict(
language_code=subdir0.tp.language.code,
project_code=subdir0.tp.project.code,
dir_path=subdir0.tp_path[1:]))
view.request = request
view.object = view.get_object()
lang_panels = panels.gather(TPBrowseView)
assert lang_panels.keys() == ["children", "vfolders"]
assert lang_panels["children"] == ChildrenPanel
panel = ChildrenPanel(view)
assert panel.panel_name == "children"
assert (
panel.cache_key
== ("panel.%s.%s"
% (panel.panel_name, view.cache_key)))
table = {
'id': view.view_name,
'fields': panel.table_fields,
'headings': get_table_headings(panel.table_fields),
'rows': view.object_children}
assert panel.table == table
assert panel.get_context_data() == dict(
table=table, can_translate=view.can_translate)
content = loader.render_to_string(
panel.template_name, context=panel.get_context_data())
assert (
panel.content
== panel.update_times(content))
def test_panel_tp_vfolder_table(tp0, rf, member):
request = rf.get('/language0/project0/')
request.user = member
request.permissions = get_matching_permissions(
request.user,
tp0.directory)
view = TPBrowseView(
kwargs=dict(
language_code=tp0.language.code,
project_code=tp0.project.code))
view.request = request
view.object = view.get_object()
lang_panels = panels.gather(TPBrowseView)
assert lang_panels.keys() == ["children", "vfolders"]
assert lang_panels["vfolders"] == VFolderPanel
panel = VFolderPanel(view)
assert panel.panel_name == "vfolder"
assert (
panel.cache_key
== ("panel.%s.%s"
% (panel.panel_name, view.cache_key)))
table = view.vfolders_data_view.table_data["children"]
assert panel.table == table
assert panel.get_context_data() == dict(
table=table, can_translate=view.can_translate)
content = loader.render_to_string(
panel.template_name, context=panel.get_context_data())
assert (
panel.content
== panel.update_times(content))
def _wrapped(request, *args, **kwargs):
path_obj = args[0]
directory = getattr(path_obj, 'directory', path_obj)
# HACKISH: some old code relies on
# `request.translation_project`, `request.language` etc.
# being set, so we need to set that too.
attr_name = CLS2ATTR.get(path_obj.__class__.__name__,
'path_obj')
setattr(request, attr_name, path_obj)
User = get_user_model()
request.profile = User.get(request.user)
request.permissions = get_matching_permissions(request.profile,
directory)
if not permission_code:
return func(request, *args, **kwargs)
if not check_permission(permission_code, request):
raise PermissionDenied(
_("Insufficient rights to access this page."),
)
return func(request, *args, **kwargs)
def project_language_index(request, project_code):
"""page listing all languages added to project"""
project = get_object_or_404(Project, code=project_code)
request.permissions = get_matching_permissions(get_profile(request.user), project.directory)
if not check_permission('view', request):
raise PermissionDenied
translation_projects = project.translationproject_set.all()
items = [make_language_item(request, translation_project) for translation_project in translation_projects.iterator()]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
languagecount = len(translation_projects)
totals = add_percentages(project.getquickstats())
average = totals['translatedpercentage']
topstats = gentopstats_project(project)
templatevars = {
'project': {
'code': project.code,
'name': project.fullname,
'stats': ungettext('%(languages)d language, %(average)d%% translated',
'%(languages)d languages, %(average)d%% translated',
languagecount, {"languages": languagecount, "average": average}),
},
'description': project.description,
'adminlink': _('Admin'),
'languages': items,
'instancetitle': pagelayout.get_title(),
'topstats': topstats,
'statsheadings': get_stats_headings(),
'translationlegend': {'translated': _('Translations are complete'),
'fuzzy': _('Translations need to be checked (they are marked fuzzy)'),
'untranslated': _('Untranslated')},
}
return render_to_response('project/project.html', templatevars, context_instance=RequestContext(request))
def decorated_f(request, uid, *args, **kwargs):
unit = get_object_or_404(
Unit.objects.select_related("store__translation_project",
"store__parent"),
id=uid,
)
tp = unit.store.translation_project
request.translation_project = tp
User = get_user_model()
current_user = User.get(request.user)
request.profile = current_user
request.permissions = get_matching_permissions(current_user,
tp.directory)
if (permission_code is not None and
not check_permission(permission_code, request)):
raise PermissionDenied(get_permission_message(permission_code))
request.unit = unit
request.store = unit.store
request.directory = unit.store.parent
return f(request, unit, *args, **kwargs)
def project_settings_edit(request, project_code):
project = get_object_or_404(Project, code=project_code)
request.permissions = get_matching_permissions(
get_profile(request.user), project.directory
)
if not check_permission('administrate', request):
raise PermissionDenied
from pootle_project.forms import DescriptionForm
form = DescriptionForm(request.POST, instance=project)
response = {}
if form.is_valid():
form.save()
response = {
"intro": form.cleaned_data['description'],
"valid": True,
}
context = {
"form": form,
"form_action": project.pootle_path + "edit_settings.html",
}
t = loader.get_template('admin/general_settings_form.html')
c = RequestContext(request, context)
response['form'] = t.render(c)
return HttpResponse(jsonify(response), mimetype="application/json")
def projects_index(request):
"""page listing all projects"""
request.permissions = get_matching_permissions(get_profile(request.user),
Directory.objects.root)
if not check_permission('view', request):
raise PermissionDenied
topstats = gentopstats_root()
templatevars = {
'projects': getprojects(request),
'topstats': topstats,
'translationlegend': {
'translated':
_('Translations are complete'),
'fuzzy':
_('Translations need to be checked '
'(they are marked fuzzy)'),
'untranslated':
_('Untranslated')
},
}
return render_to_response('project/projects.html', templatevars,
RequestContext(request))
def test_panel_tp_subdir_table(subdir0, rf, member):
request = rf.get(subdir0.pootle_path)
request.user = member
request.permissions = get_matching_permissions(request.user, subdir0)
view = TPBrowseView(kwargs=dict(language_code=subdir0.tp.language.code,
project_code=subdir0.tp.project.code,
dir_path=subdir0.tp_path[1:]))
view.request = request
view.object = view.get_object()
lang_panels = panels.gather(TPBrowseView)
assert lang_panels.keys() == ["children", "vfolders"]
assert lang_panels["children"] == ChildrenPanel
panel = ChildrenPanel(view)
assert panel.panel_name == "children"
assert (panel.cache_key == ("panel.%s.%s" %
(panel.panel_name, view.cache_key)))
table = {
'id': view.view_name,
'fields': panel.table_fields,
'headings': get_table_headings(panel.table_fields),
'rows': view.object_children
}
assert panel.table == table
assert panel.get_context_data() == dict(table=table,
can_translate=view.can_translate)
content = loader.render_to_string(panel.template_name,
context=panel.get_context_data())
assert (panel.content == panel.update_times(content))
def GET(self, template_vars, request, translation_project, directory):
template_vars = super(TPReviewView, self).GET(template_vars, request)
request.permissions = get_matching_permissions(
get_profile(request.user), translation_project.directory)
project = translation_project.project
language = translation_project.language
is_terminology = project.is_terminology
children = get_children(request, translation_project, directory,
links_required='review')
navitems = [navbar_dict.make_directory_navbar_dict(
request, directory, links_required='review',
terminology=is_terminology)]
template_vars.update({
'translation_project': translation_project,
'project': project,
'language': language,
'directory': directory,
'children': children,
'navitems': navitems,
'topstats': gentopstats_translation_project(translation_project),
'feed_path': directory.pootle_path[1:],
})
return template_vars
def _wrapped(request, *args, **kwargs):
path_obj = args[0]
directory = (path_obj if isinstance(path_obj, Directory)
else path_obj.directory)
# HACKISH: some old code relies on `request.translation_project`,
# `request.language` etc. being set, so we need to set that too.
attr_name = CLS2ATTR.get(path_obj.__class__.__name__,
'path_obj')
setattr(request, attr_name, path_obj)
request.profile = get_profile(request.user)
request.permissions = get_matching_permissions(request.profile,
directory)
if not permission_codes:
return func(request, *args, **kwargs)
permission_codes_list = permission_codes
if isinstance(permission_codes, basestring):
permission_codes_list = [permission_codes]
for permission_code in permission_codes_list:
if not check_permission(permission_code, request):
raise PermissionDenied(
_("Insufficient rights to access this page."),
)
return func(request, *args, **kwargs)
def view(request, path):
# FIXME: why do we have leading and trailing slashes in pootle_path?
pootle_path = "/%s" % path
directory = get_object_or_404(Directory, pootle_path=pootle_path)
request.permissions = get_matching_permissions(get_profile(request.user), directory)
if not check_permission("view", request):
raise PermissionDenied
template_vars = {"path": path, "directory": directory}
if check_permission("administrate", request):
template_vars["form"] = handle_form(request, directory)
template_vars["title"] = directory_to_title(directory)
if request.GET.get("all", False):
template_vars["notices"] = Notice.objects.filter(
directory__pootle_path__startswith=directory.pootle_path
).select_related("directory")[:30]
else:
template_vars["notices"] = Notice.objects.filter(directory=directory).select_related("directory")[:30]
if not directory.is_language() and not directory.is_project():
try:
request.translation_project = directory.get_translationproject()
template_vars["navitems"] = [navbar_dict.make_directory_navbar_dict(request, directory)]
template_vars["translation_project"] = request.translation_project
template_vars["language"] = request.translation_project.language
template_vars["project"] = request.translation_project.project
except:
pass
return render_to_response("notices.html", template_vars, context_instance=RequestContext(request))
def decorated_f(request, uid, *args, **kwargs):
unit = get_object_or_404(
Unit.objects.select_related("store__translation_project",
"store__parent"),
id=uid,
)
tp = unit.store.translation_project
request.translation_project = tp
User = get_user_model()
current_user = User.get(request.user)
request.profile = current_user
request.permissions = get_matching_permissions(
current_user, tp.directory)
if (permission_code is not None
and not check_permission(permission_code, request)):
raise PermissionDenied(get_permission_message(permission_code))
request.unit = unit
request.store = unit.store
request.directory = unit.store.parent
return f(request, unit, *args, **kwargs)
def view(request, path):
#FIXME: why do we have leading and trailing slashes in pootle_path?
pootle_path = '/%s' % path
directory = get_object_or_404(Directory, pootle_path=pootle_path)
request.permissions = get_matching_permissions(get_profile(request.user), directory)
if not check_permission('view', request):
raise PermissionDenied
template_vars = {'path': path,
'directory': directory}
if check_permission('administrate', request):
template_vars['form'] = handle_form(request, directory)
template_vars['title'] = directory_to_title(request, directory)
if request.GET.get('all', False):
template_vars['notices'] = Notice.objects.filter(directory__pootle_path__startswith=directory.pootle_path).select_related('directory')[:30]
else:
template_vars['notices'] = Notice.objects.filter(directory=directory).select_related('directory')[:30]
if not directory.is_language() and not directory.is_project():
try:
request.translation_project = directory.get_translationproject()
template_vars['navitems'] = [navbar_dict.make_directory_navbar_dict(request, directory)]
template_vars['translation_project'] = request.translation_project
template_vars['language'] = request.translation_project.language
template_vars['project'] = request.translation_project.project
except:
pass
return render_to_response('notices.html', template_vars, context_instance=RequestContext(request))
def language_index(request, language_code):
language = get_object_or_404(Language, code=language_code)
request.permissions = get_matching_permissions(get_profile(request.user), language.directory)
if not check_permission("view", request):
raise PermissionDenied
projects = language.translationproject_set.order_by('project__fullname')
projectcount = len(projects)
items = (make_project_item(translate_project) for translate_project in projects.iterator())
totals = language.getquickstats()
average = nice_percentage(totals['translatedsourcewords'] * 100.0 / max(totals['totalsourcewords'], 1))
topstats = gentopstats_language(language)
templatevars = {
'language': {
'code': language.code,
'name': tr_lang(language.fullname),
'stats': ungettext('%(projects)d project, %(average)d%% translated',
'%(projects)d projects, %(average)d%% translated',
projectcount, {"projects": projectcount, "average": average}),
},
'feed_path': '%s/' % language.code,
'projects': items,
'statsheadings': get_stats_headings(),
'topstats': topstats,
'instancetitle': pagelayout.get_title(),
}
return render_to_response("language/language_index.html", templatevars, context_instance=RequestContext(request))
def language_index(request, language_code):
language = get_object_or_404(Language, code=language_code)
request.permissions = get_matching_permissions(get_profile(request.user), language.directory)
if not check_permission("view", request):
raise PermissionDenied
projects = language.translationproject_set.order_by('project__fullname')
projectcount = len(projects)
items = (make_project_item(translate_project) for translate_project in projects.iterator())
totals = language.getquickstats()
average = nice_percentage(totals['translatedsourcewords'] * 100.0 / max(totals['totalsourcewords'], 1))
topstats = gentopstats_language(language)
templatevars = {
'language': {
'code': language.code,
'name': tr_lang(language.fullname),
'description': language.description,
'stats': ungettext('%(projects)d project, %(average)d%% translated',
'%(projects)d projects, %(average)d%% translated',
projectcount, {"projects": projectcount, "average": average}),
},
'feed_path': '%s/' % language.code,
'description': language.description,
'projects': items,
'statsheadings': get_stats_headings(),
'topstats': topstats,
}
if check_permission('administrate', request):
from pootle_language.forms import DescriptionForm
templatevars['form'] = DescriptionForm(instance=language)
return render_to_response("language/language_index.html", templatevars, context_instance=RequestContext(request))
def test_panel_projects_table(rf, member, project0):
request = rf.get('/projects/')
request.user = member
request.permissions = get_matching_permissions(
request.user,
project0.directory.parent)
view = ProjectsBrowseView()
view.request = request
view.object = view.get_object()
lang_panels = panels.gather(ProjectsBrowseView)
assert lang_panels.keys() == ["children"]
assert lang_panels["children"] == ChildrenPanel
panel = ChildrenPanel(view)
assert panel.panel_name == "children"
assert (
panel.cache_key
== ("panel.%s.%s"
% (panel.panel_name, view.cache_key)))
table = {
'id': view.view_name,
'fields': panel.table_fields,
'headings': get_table_headings(panel.table_fields),
'rows': view.object_children}
assert panel.table == table
assert panel.get_context_data() == dict(
table=table, can_translate=view.can_translate)
content = loader.render_to_string(
panel.template_name, context=panel.get_context_data())
assert (
panel.content
== panel.update_times(content))
def tp_settings_edit(request, translation_project):
request.permissions = get_matching_permissions(
get_profile(request.user), translation_project.directory
)
if not check_permission('administrate', request):
raise PermissionDenied
from pootle_translationproject.forms import DescriptionForm
form = DescriptionForm(request.POST, instance=translation_project)
response = {}
if form.is_valid():
form.save()
response = {
"intro": form.cleaned_data['description'],
"valid": True,
}
context = {
"form": form,
"form_action": translation_project.pootle_path + "edit_settings.html",
}
t = loader.get_template('admin/general_settings_form.html')
c = RequestContext(request, context)
response['form'] = t.render(c)
return HttpResponse(jsonify(response), mimetype="application/json")
def method_wrapper(self, request, *args, **kwargs):
User = get_user_model()
request.profile = User.get(self.request.user)
request.permissions = get_matching_permissions(
request.profile,
self.permission_context) or []
return f(self, request, *args, **kwargs)
def view(request):
request.permissions = get_matching_permissions(get_profile(request.user), Directory.objects.root)
topstats = gentopstats_root()
templatevars = {
"description": pagelayout.get_description(),
"keywords": [
"Pootle",
"translate",
"translation",
"localisation",
"localization",
"l10n",
"traduction",
"traduire",
],
"languagelink": _("Languages"),
"languages": getlanguages(request),
"projectlink": _("Projects"),
"projects": getprojects(request),
"topstats": topstats,
"instancetitle": pagelayout.get_title(),
"translationlegend": {
"translated": _("Translations are complete"),
"fuzzy": _("Translations need to be checked (they are marked fuzzy)"),
"untranslated": _("Untranslated"),
},
"permissions": request.permissions,
}
visible_langs = [l for l in templatevars["languages"] if l["total"] != 0]
templatevars["moreprojects"] = len(templatevars["projects"]) > len(visible_langs)
return render_to_response("index/index.html", templatevars, RequestContext(request))
def decorated_f(request, translation_project, *args, **kwargs):
# For now, all permissions in a translation project are
# relative to the root of that translation project.
request.permissions = get_matching_permissions(
get_profile(request.user), translation_project.directory)
request.translation_project = translation_project
return f(request, translation_project, *args, **kwargs)
def _wrapped(request, *args, **kwargs):
path_obj = args[0]
directory = (path_obj if isinstance(path_obj, Directory) else
path_obj.directory)
# HACKISH: some old code relies on `request.translation_project`,
# `request.language` etc. being set, so we need to set that too.
attr_name = CLS2ATTR.get(path_obj.__class__.__name__, 'path_obj')
setattr(request, attr_name, path_obj)
request.profile = get_profile(request.user)
request.permissions = get_matching_permissions(
request.profile, directory)
if not permission_codes:
return func(request, *args, **kwargs)
permission_codes_list = permission_codes
if isinstance(permission_codes, basestring):
permission_codes_list = [permission_codes]
for permission_code in permission_codes_list:
if not check_permission(permission_code, request):
raise PermissionDenied(
_("Insufficient rights to access this page."), )
return func(request, *args, **kwargs)
def GET(self, template_vars, request, translation_project, directory):
template_vars = super(ProjectIndexView, self).GET(template_vars, request)
request.permissions = get_matching_permissions(get_profile(request.user), translation_project.directory)
state = dispatch.ProjectIndexState(request.GET)
project = translation_project.project
language = translation_project.language
is_terminology = project.is_terminology
description = translation_project.description
directory_stats = get_raw_directory_stats(directory)
directory_summary = get_directory_summary(directory, directory_stats)
template_vars.update({
'translation_project': translation_project,
'description': description,
'project': project,
'language': language,
'directory': directory,
'children': get_children(request, translation_project, directory),
'dir_summary': directory_summary,
'stats_headings': get_stats_headings(),
'topstats': gentopstats_translation_project(translation_project),
'feed_path': directory.pootle_path[1:],
})
if check_permission('administrate', request):
from pootle_translationproject.forms import DescriptionForm
template_vars['form'] = DescriptionForm(instance=translation_project)
return template_vars
def _create_post_request(rf, directory, user, url='/', data={}):
"""Convenience function to create and setup fake POST requests."""
request = rf.post(url, data=data)
request.user = user
request.profile = get_profile(user)
request.permissions = get_matching_permissions(request.profile,
directory)
return request
def view(request, path):
#FIXME: why do we have leading and trailing slashes in pootle_path?
pootle_path = '/%s' % path
directory = get_object_or_404(Directory, pootle_path=pootle_path)
request.permissions = get_matching_permissions(get_profile(request.user),
directory)
if not check_permission('view', request):
raise PermissionDenied
template_vars = {'path': path, 'directory': directory}
# Find language and project defaults, passed to handle_form
proj = None
lang = None
if not directory.is_language() and not directory.is_project():
translation_project = directory.translation_project
lang = translation_project.language
proj = translation_project.project
else:
if directory.is_language():
lang = directory.language
proj = None
if directory.is_project():
lang = None
proj = directory.project
if check_permission('administrate', request):
# Thus, form is only set for the template if the user has
# 'administrate' permission
template_vars['form'] = handle_form(request, directory, proj, lang,
template_vars)
template_vars['title'] = directory_to_title(directory)
else:
template_vars['form'] = None
if request.GET.get('all', False):
template_vars['notices'] = Notice.objects.filter(
directory__pootle_path__startswith=directory.pootle_path
).select_related('directory')[:30]
else:
template_vars['notices'] = Notice.objects.filter(
directory=directory).select_related('directory')[:30]
if not directory.is_language() and not directory.is_project():
request.translation_project = directory.translation_project
template_vars['navitems'] = [
navbar_dict.make_directory_navbar_dict(request, directory)
]
template_vars['translation_project'] = request.translation_project
template_vars['language'] = request.translation_project.language
template_vars['project'] = request.translation_project.project
return render_to_response('notices.html',
template_vars,
context_instance=RequestContext(request))
def decorated_f(request, path_obj, *args, **kwargs):
request.permissions = get_matching_permissions(
get_profile(request.user), path_obj.directory)
if check_permission(permission_code, request):
return f(request, path_obj, *args, **kwargs)
else:
raise PermissionDenied(
_("You do not have rights to administer %s.",
path_obj.fullname))
def decorated_function(request, path_obj, *args, **kwargs):
request.permissions = get_matching_permissions(
get_profile(request.user), path_obj.directory)
if check_permission(permission_code, request):
return function(request, path_obj, *args, **kwargs)
else:
raise PermissionDenied(
_("You do not have rights to administer %s.",
path_obj.fullname))
def _create_post_request(rf, directory, user, url='/', data=None):
"""Convenience function to create and setup fake POST requests."""
if data is None:
data = {}
request = rf.post(url, data=data)
request.user = user
request.permissions = get_matching_permissions(request.user, directory)
return request
def _create_post_request(rf, directory, user, url='/', data=None):
"""Convenience function to create and setup fake POST requests."""
if data is None:
data = {}
request = rf.post(url, data=data)
request.user = user
request.permissions = get_matching_permissions(request.user, directory)
return request
def view(request, root_dir):
request.permissions = get_matching_permissions(get_profile(request.user),
root_dir)
can_edit = request.user.is_superuser
languages = getlanguages(request)
languages_table_fields = ['language', 'progress', 'activity']
languages_table = {
'id': 'index-languages',
'proportional': False,
'fields': languages_table_fields,
'headings': get_table_headings(languages_table_fields),
'items': languages,
}
projects = getprojects(request)
projects_table_fields = ['project', 'progress', 'activity']
projects_table = {
'id': 'index-projects',
'proportional': False,
'fields': projects_table_fields,
'headings': get_table_headings(projects_table_fields),
'items': projects,
}
siteconfig = load_site_config()
ctx = {
'description': _(siteconfig.get('DESCRIPTION')),
'keywords': [
'Pootle',
'translate',
'translation',
'localisation',
'localization',
'l10n',
'traduction',
'traduire',
],
'topstats': gentopstats_root(),
'permissions': request.permissions,
'can_edit': can_edit,
'languages_table': languages_table,
'projects_table': projects_table,
'resource_obj': request.resource_obj,
'moreprojects': (len(projects) > len(languages))
}
if can_edit:
from pootle_app.forms import GeneralSettingsForm
ctx.update({
'form': GeneralSettingsForm(siteconfig),
'form_action': reverse('pootle-admin-edit-settings'),
})
return render_to_response('home/home.html', ctx,
RequestContext(request))
def method_wrapper(self, request, *args, **kwargs):
User = get_user_model()
request.profile = User.get(self.request.user)
try:
request.permissions = get_matching_permissions(
request.profile,
self.permission_context) or []
except Http404 as e:
# Test if lang code is not canonical but valid
lang = Language.get_canonical(kwargs['language_code'])
if lang is not None and lang.code != kwargs['language_code']:
kwargs["language_code"] = lang.code
return redirect(
resolve(request.path).view_name,
permanent=True,
**kwargs)
elif kwargs["dir_path"] or kwargs.get("filename", None):
try:
TranslationProject.objects.get(
project__code=kwargs["project_code"],
language__code=kwargs["language_code"])
# the TP exists so redirect to it
return redirect(
reverse(
'pootle-tp-browse',
kwargs={
k: v
for k, v
in kwargs.items()
if k in [
"language_code",
"project_code"]}))
except TranslationProject.DoesNotExist:
pass
# if we get here - the TP does not exist
user_choice = self.request.COOKIES.get(
'user-choice', None)
if user_choice:
url = None
if user_choice == 'language':
url = reverse(
'pootle-language-browse',
args=[kwargs["language_code"]])
elif user_choice == "project":
url = reverse(
'pootle-project-browse',
args=[kwargs["project_code"], '', ''])
if url:
response = redirect(url)
response.delete_cookie('user-choice')
return response
raise e
return f(self, request, *args, **kwargs)
def view(request, root_dir):
request.permissions = get_matching_permissions(get_profile(request.user),
root_dir)
can_edit = request.user.is_superuser
languages = getlanguages(request)
languages_table_fields = ['language', 'progress', 'activity']
languages_table = {
'id': 'index-languages',
'proportional': False,
'fields': languages_table_fields,
'headings': get_table_headings(languages_table_fields),
'items': languages,
}
projects = getprojects(request)
projects_table_fields = ['project', 'progress', 'activity']
projects_table = {
'id': 'index-projects',
'proportional': False,
'fields': projects_table_fields,
'headings': get_table_headings(projects_table_fields),
'items': projects,
}
templatevars = {
'description': _(settings.DESCRIPTION),
'keywords': [
'Pootle',
'translate',
'translation',
'localisation',
'localization',
'l10n',
'traduction',
'traduire',
],
'topstats': gentopstats_root(),
'permissions': request.permissions,
'can_edit': can_edit,
'languages_table': languages_table,
'projects_table': projects_table,
'resource_obj': request.resource_obj,
}
templatevars['moreprojects'] = (len(projects) > len(languages))
if can_edit:
from pootle_misc.siteconfig import load_site_config
from pootle_app.forms import GeneralSettingsForm
siteconfig = load_site_config()
setting_form = GeneralSettingsForm(siteconfig)
templatevars['form'] = setting_form
return render_to_response('index/index.html', templatevars,
RequestContext(request))
def tp_review(request, translation_project, dir_path):
request.permissions = get_matching_permissions(get_profile(request.user),
translation_project.directory)
if not check_permission("view", request):
raise PermissionDenied(_("You do not have rights to access review mode."))
directory = get_object_or_404(Directory, pootle_path=translation_project.directory.pootle_path + dir_path)
view_obj = TPReviewView({})
return render_to_response("translation_project/tp_review.html",
view_obj(request, translation_project, directory),
context_instance=RequestContext(request))
def view(request):
request.permissions = get_matching_permissions(get_profile(request.user),
Directory.objects.root)
can_edit = request.user.is_superuser
topstats = gentopstats_root()
languages = getlanguages(request)
templatevars = {
'description':
_(settings.DESCRIPTION),
'keywords': [
'Pootle',
'translate',
'translation',
'localisation',
'localization',
'l10n',
'traduction',
'traduire',
],
'languages':
languages,
'projects':
getprojects(request),
'topstats':
topstats,
'translationlegend': {
'translated':
_('Translations are complete'),
'fuzzy':
_("Translations need to be checked "
"(they are marked fuzzy)"),
'untranslated':
_('Untranslated')
},
'permissions':
request.permissions,
'can_edit':
can_edit,
}
visible_langs = [l for l in languages if l['stats']['total']['words'] != 0]
templatevars['moreprojects'] = (len(templatevars['projects']) >
len(visible_langs))
if can_edit:
from pootle_misc.siteconfig import load_site_config
from pootle_app.forms import GeneralSettingsForm
siteconfig = load_site_config()
setting_form = GeneralSettingsForm(siteconfig)
templatevars['form'] = setting_form
return render_to_response('index/index.html', templatevars,
RequestContext(request))
def translate(request, pootle_path):
if pootle_path[0] != '/':
pootle_path = '/' + pootle_path
try:
store = Store.objects.select_related('translation_project', 'parent').get(pootle_path=pootle_path)
except Store.DoesNotExist:
raise Http404
request.translation_project = store.translation_project
request.permissions = get_matching_permissions(get_profile(request.user), request.translation_project.directory)
return translate_page(request, store.units, store=store)
def _check_permissions(request, directory, permission_code):
"""Checks if the current user has enough permissions defined by
`permission_code` in the current`directory`.
"""
request.permissions = get_matching_permissions(request.user, directory)
if not permission_code:
return
if not check_permission(permission_code, request):
raise PermissionDenied(get_permission_message(permission_code))
def project_admin(request, project_code):
"""adding and deleting project languages"""
current_project = Project.objects.get(code=project_code)
request.permissions = get_matching_permissions(
get_profile(request.user), current_project.directory)
if not check_permission('administrate', request):
raise PermissionDenied(_(
"You do not have rights to administer this project."))
template_translation_project = current_project. \
get_template_translationproject()
class TranslationProjectForm(forms.ModelForm):
if template_translation_project is not None:
update = forms.BooleanField(required=False, label=_(
"Update from templates"))
#FIXME: maybe we can detect if initialize is needed to avoid
# displaying it when not relevant
# initialize = forms.BooleanField(
# required=False, label=_("Initialize"))
project = forms.ModelChoiceField(
queryset=Project.objects.filter(pk=current_project.pk),
initial=current_project.pk, widget=forms.HiddenInput)
language = LiberalModelChoiceField(
label=_("Language"),
queryset=Language.objects.exclude(
translationproject__project=current_project))
class Meta:
prefix = "existing_language"
model = TranslationProject
def process_extra_fields(self):
if self.instance.pk is not None:
if self.cleaned_data.get('initialize', None):
self.instance.initialize()
if self.cleaned_data.get('update', None) or not \
self.instance.stores.count():
self.instance.update_from_templates()
queryset = TranslationProject.objects.filter(
project=current_project).order_by('pootle_path')
model_args = {}
model_args['project'] = {'code': current_project.code,
'name': current_project.fullname}
model_args['formid'] = "translation-projects"
model_args['submitname'] = "changetransprojects"
link = lambda instance: '<a href="/wikitrans%s">%s</a>' % (
l(instance.pootle_path + 'admin_permissions.html'), instance.language)
return util.edit(
request, 'project/project_admin.html', TranslationProject,
model_args, link, linkfield="language",
queryset=queryset, can_delete=True, form=TranslationProjectForm,
formset=TranslationProjectFormSet)
def tp_overview(request, translation_project, dir_path):
request.permissions = get_matching_permissions(get_profile(request.user),
translation_project.directory)
if not check_permission("view", request):
raise PermissionDenied(_("You do not have rights to access this translation project."))
directory = get_object_or_404(Directory, pootle_path=translation_project.directory.pootle_path + dir_path)
view_obj = ProjectIndexView(forms=dict(upload=UploadHandler,
update=UpdateHandler))
return render_to_response("translation_project/tp_overview.html",
view_obj(request, translation_project, directory),
context_instance=RequestContext(request))
def project_language_index(request, project_code):
"""page listing all languages added to project"""
project = get_object_or_404(Project, code=project_code)
request.permissions = get_matching_permissions(
get_profile(request.user), project.directory
)
if not check_permission('view', request):
raise PermissionDenied
can_edit = check_permission('administrate', request)
translation_projects = project.translationproject_set.all()
items = [make_language_item(request, translation_project) \
for translation_project in translation_projects.iterator()]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
languagecount = len(translation_projects)
project_stats = get_raw_stats(project)
average = project_stats['translated']['percentage']
topstats = gentopstats_project(project)
table_fields = ['name', 'progress', 'total', 'need-translation', 'activity']
table = {
'id': 'project',
'proportional': False,
'fields': table_fields,
'headings': get_table_headings(table_fields),
'items': items,
}
templatevars = {
'project': {
'code': project.code,
'name': project.fullname,
'description': project.description,
'summary': ungettext('%(languages)d language, %(average)d%% translated',
'%(languages)d languages, %(average)d%% translated',
languagecount, {"languages": languagecount,
"average": average}),
},
'topstats': topstats,
'can_edit': can_edit,
'table': table,
}
if can_edit:
from pootle_project.forms import DescriptionForm
templatevars['form'] = DescriptionForm(instance=project)
return render_to_response('project/project.html', templatevars,
context_instance=RequestContext(request))
def get_object(self, request, path):
pootle_path = '/%s' % path
directory = get_object_or_404(Directory, pootle_path=pootle_path)
request.permissions = get_matching_permissions(get_profile(request.user), directory)
if not check_permission('view', request):
raise PermissionDenied
self.directory = directory
self.link = l(directory.pootle_path)
self.recusrive = request.GET.get('all', False)
return self.directory
def method_wrapper(self, request, *args, **kwargs):
try:
request.permissions = get_matching_permissions(
request.user,
self.permission_context) or []
except Http404 as e:
# Test if lang code is not canonical but valid
lang = Language.get_canonical(kwargs['language_code'])
if lang is not None and lang.code != kwargs['language_code']:
kwargs["language_code"] = lang.code
return redirect(
resolve(request.path).view_name,
permanent=True,
**kwargs)
elif kwargs["dir_path"] or kwargs.get("filename", None):
try:
TranslationProject.objects.get(
project__code=kwargs["project_code"],
language__code=kwargs["language_code"])
# the TP exists so redirect to it
return redirect(
reverse(
'pootle-tp-browse',
kwargs={
k: v
for k, v
in kwargs.items()
if k in [
"language_code",
"project_code"]}))
except TranslationProject.DoesNotExist:
pass
# if we get here - the TP does not exist
user_choice = self.request.COOKIES.get(
'user-choice', None)
if user_choice:
url = None
if user_choice == 'language':
url = reverse(
'pootle-language-browse',
args=[kwargs["language_code"]])
elif user_choice == "project":
url = reverse(
'pootle-project-browse',
args=[kwargs["project_code"], '', ''])
if url:
response = redirect(url)
response.delete_cookie('user-choice')
return response
raise e
return f(self, request, *args, **kwargs)
def view(request, path):
pootle_path = '/%s' % path
directory = get_object_or_404(Directory, pootle_path=pootle_path)
request.permissions = get_matching_permissions(get_profile(request.user), directory)
if not check_permission('view', request):
raise PermissionDenied
feedgen = NoticeFeed(pootle_path, request, directory).get_feed(path)
response = HttpResponse(mimetype=feedgen.mime_type)
feedgen.write(response, 'utf-8')
return response
def get_object(self, request, path):
pootle_path = '/%s' % path
directory = get_object_or_404(Directory, pootle_path=pootle_path)
request.permissions = get_matching_permissions(
get_profile(request.user), directory)
if not check_permission('view', request):
raise PermissionDenied
self.directory = directory
self.link = l(directory.pootle_path)
self.recusrive = request.GET.get('all', False)
return self.directory
def project_language_index(request, project_code):
"""page listing all languages added to project"""
project = get_object_or_404(Project, code=project_code)
request.permissions = get_matching_permissions(get_profile(request.user),
project.directory)
if not check_permission('view', request):
raise PermissionDenied
can_edit = check_permission('administrate', request)
translation_projects = project.translationproject_set.all()
items = [make_language_item(request, translation_project) \
for translation_project in translation_projects.iterator()]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
languagecount = len(translation_projects)
project_stats = get_raw_stats(project)
average = project_stats['translated']['percentage']
topstats = gentopstats_project(project)
templatevars = {
'project': {
'code':
project.code,
'name':
project.fullname,
'description_html':
project.description_html,
'summary':
ungettext('%(languages)d language, %(average)d%% translated',
'%(languages)d languages, %(average)d%% translated',
languagecount, {
"languages": languagecount,
"average": average
}),
},
'languages': items,
'topstats': topstats,
'statsheadings': get_stats_headings(),
'can_edit': can_edit,
}
if can_edit:
from pootle_project.forms import DescriptionForm
templatevars['form'] = DescriptionForm(instance=project)
return render_to_response('project/project.html',
templatevars,
context_instance=RequestContext(request))
def translate(request, pootle_path):
if pootle_path[0] != '/':
pootle_path = '/' + pootle_path
try:
store = Store.objects.select_related(
'translation_project', 'parent').get(pootle_path=pootle_path)
except Store.DoesNotExist:
raise Http404
request.translation_project = store.translation_project
request.permissions = get_matching_permissions(
get_profile(request.user), request.translation_project.directory)
return translate_page(request, store.units, store=store)
def project_language_index(request, project_code):
"""page listing all languages added to project"""
project = get_object_or_404(Project, code=project_code)
request.permissions = get_matching_permissions(get_profile(request.user),
project.directory)
if not check_permission('view', request):
raise PermissionDenied
translation_projects = project.translationproject_set.all()
items = [
make_language_item(request, translation_project)
for translation_project in translation_projects.iterator()
]
items.sort(lambda x, y: locale.strcoll(x['title'], y['title']))
languagecount = len(translation_projects)
totals = add_percentages(project.getquickstats())
average = totals['translatedpercentage']
topstats = gentopstats_project(project)
templatevars = {
'project': {
'code':
project.code,
'name':
project.fullname,
'stats':
ungettext('%(languages)d language, %(average)d%% translated',
'%(languages)d languages, %(average)d%% translated',
languagecount, {
"languages": languagecount,
"average": average
}),
},
'description': project.description,
'adminlink': _('Admin'),
'languages': items,
'instancetitle': pagelayout.get_title(),
'topstats': topstats,
'statsheadings': get_stats_headings(),
'translationlegend': {
'translated': _('Translations are complete'),
'fuzzy':
_('Translations need to be checked (they are marked fuzzy)'),
'untranslated': _('Untranslated')
},
}
return render_to_response('project/project.html',
templatevars,
context_instance=RequestContext(request))
def language_admin(request, language_code):
# Check if the user can access this view
language = get_object_or_404(Language, code=language_code)
request.permissions = get_matching_permissions(get_profile(request.user),
language.directory)
if not check_permission('administrate', request):
raise PermissionDenied(_("You do not have rights to administer this language."))
template_vars = {
"language": language,
"directory": language.directory,
"feed_path": '%s/' % language.code,
}
return admin_permissions(request, language.directory, "language/language_admin.html", template_vars)
def view(request, path_obj):
directory = path_obj.directory
# Find language and project defaults, passed to handle_form.
proj = None
lang = None
if directory.is_translationproject():
trans_proj = path_obj
lang = path_obj.language
proj = path_obj.project
elif directory.is_language():
lang = path_obj
elif directory.is_project():
proj = path_obj
else:
# Notices lists are only shown for languages, projects or TPs.
raise Http404
# Set permissions on request in order to allow check them later using
# different functions.
request.permissions = get_matching_permissions(get_profile(request.user),
directory)
if request.GET.get('all', False):
criteria = {
'directory__pootle_path__startswith': directory.pootle_path,
}
else:
criteria = {
'directory': directory,
}
ctx = {
'page': 'news',
'notification_url': reverse('pootle-notifications-feed',
args=[path_obj.pootle_path[:1]]),
'directory': directory,
'title': directory_to_title(directory),
'notices': Notice.objects.filter(**criteria) \
.select_related('directory')[:30],
'language': lang,
'project': proj,
}
if check_permission('administrate', request):
ctx['form'] = handle_form(request, directory, proj, lang, ctx)
return render(request, "notifications/notices.html", ctx)
def tp_review(request, translation_project, dir_path):
request.permissions = get_matching_permissions(
get_profile(request.user), translation_project.directory)
if not check_permission("view", request):
raise PermissionDenied(
_("You do not have rights to access review mode."))
directory = get_object_or_404(
Directory,
pootle_path=translation_project.directory.pootle_path + dir_path)
view_obj = TPReviewView({})
return render_to_response("translation_project/tp_review.html",
view_obj(request, translation_project,
directory),
context_instance=RequestContext(request))
def tp_overview(request, translation_project, dir_path):
request.permissions = get_matching_permissions(
get_profile(request.user), translation_project.directory)
if not check_permission("view", request):
raise PermissionDenied(
_("You do not have rights to access this translation project."))
directory = get_object_or_404(
Directory,
pootle_path=translation_project.directory.pootle_path + dir_path)
view_obj = ProjectIndexView(
forms=dict(upload=UploadHandler, update=UpdateHandler))
return render_to_response("translation_project/tp_overview.html",
view_obj(request, translation_project,
directory),
context_instance=RequestContext(request))
def view(request, path):
#FIXME: why do we have leading and trailing slashes in pootle_path?
pootle_path = '/%s' % path
directory = get_object_or_404(Directory, pootle_path=pootle_path)
# Set permissions on request in order to allow check them later using
# different functions.
request.permissions = get_matching_permissions(get_profile(request.user),
directory)
if request.GET.get('all', False):
criteria = {
'directory__pootle_path__startswith': directory.pootle_path,
}
else:
criteria = {
'directory': directory,
}
# Find language and project defaults, passed to handle_form
proj = None
lang = None
if not directory.is_language() and not directory.is_project():
trans_proj = directory.translation_project
lang = trans_proj.language
proj = trans_proj.project
elif directory.is_language():
lang = directory.language
elif directory.is_project():
proj = directory.project
template_vars = {
'path': path,
'directory': directory,
'title': directory_to_title(directory),
'notices': Notice.objects.filter(**criteria) \
.select_related('directory')[:30],
'language': lang,
'project': proj,
}
if check_permission('administrate', request):
template_vars['form'] = handle_form(request, directory, proj, lang,
template_vars)
return render_to_response('notices.html',
template_vars,
context_instance=RequestContext(request))
def project_admin_permissions(request, project_code):
# Check if the user can access this view
project = get_object_or_404(Project, code=project_code)
request.permissions = get_matching_permissions(get_profile(request.user),
project.directory)
if not check_permission('administrate', request):
raise PermissionDenied(
_("You do not have rights to administer this project."))
template_vars = {
"project": project,
"directory": project.directory,
"feed_path": project.pootle_path[1:],
}
return admin_permissions(request, project.directory,
"project/admin_permissions.html", template_vars)
