def get_context_data(self, *args, **kwargs):
priority = (
self.object.priority if 'virtualfolder' in settings.INSTALLED_APPS
else None
)
return {
'unit': self.object,
'form': self.get_unit_edit_form(),
'comment_form': self.get_unit_comment_form(),
'priority': priority,
'store': self.store,
'directory': self.directory,
'user': self.request.user,
'project': self.project,
'language': self.language,
'source_language': self.source_language,
'cantranslate': check_user_permission(self.request.user,
"translate",
self.directory),
'cantranslatexlang': check_user_permission(self.request.user,
"administrate",
self.project.directory),
'cansuggest': check_user_permission(self.request.user,
"suggest",
self.directory),
'canreview': check_user_permission(self.request.user,
"review",
self.directory),
'is_admin': check_user_permission(self.request.user,
'administrate',
self.directory),
'altsrcs': self.get_alt_srcs()}
def get_context_data(self, *args, **kwargs):
priority = (
self.object.priority if 'virtualfolder' in settings.INSTALLED_APPS
else None
)
return {
'unit': self.object,
'form': self.get_unit_edit_form(),
'comment_form': self.get_unit_comment_form(),
'priority': priority,
'store': self.store,
'directory': self.directory,
'user': self.request.user,
'project': self.project,
'language': self.language,
'source_language': self.source_language,
'cantranslate': check_user_permission(self.request.user,
"translate",
self.directory),
'cantranslatexlang': check_user_permission(self.request.user,
"administrate",
self.project.directory),
'cansuggest': check_user_permission(self.request.user,
"suggest",
self.directory),
'canreview': check_user_permission(self.request.user,
"review",
self.directory),
'has_admin_access': check_user_permission(self.request.user,
'administrate',
self.directory),
'altsrcs': self.get_alt_srcs()}
def get_context_data(self, *args, **kwargs):
return {
'unit': self.object,
'form': self.get_unit_edit_form(),
'comment_form': self.get_unit_comment_form(),
'store': self.store,
'directory': self.directory,
'user': self.request.user,
'project': self.project,
'language': self.language,
'source_language': self.source_language,
'cantranslate': check_user_permission(self.request.user,
"translate",
self.directory),
'cantranslatexlang': check_user_permission(self.request.user,
"administrate",
self.project.directory),
'cansuggest': check_user_permission(self.request.user,
"suggest",
self.directory),
'canreview': check_user_permission(self.request.user,
"review",
self.directory),
'has_admin_access': check_user_permission(self.request.user,
'administrate',
self.directory),
'altsrcs': {x.id: x.data for x in self.get_alt_srcs()},
'unit_values': self.get_unit_values(),
'target_nplurals': self.get_target_nplurals(),
'has_plurals': self.object.hasplural(),
}
def save_comment(request, unit):
"""Stores a new comment for the given ``unit``.
:return: If the form validates, the cleaned comment is returned.
An error message is returned otherwise.
"""
# Update current unit instance's attributes
unit.commented_by = request.user
unit.commented_on = timezone.now().replace(microsecond=0)
language = request.translation_project.language
form = unit_comment_form_factory(language)(request.POST,
instance=unit,
request=request)
if form.is_valid():
form.save()
user = request.user
directory = unit.store.parent
ctx = {
'unit': unit,
'language': language,
'cantranslate': check_user_permission(user, 'translate',
directory),
'cansuggest': check_user_permission(user, 'suggest', directory),
}
t = loader.get_template('editor/units/xhr_comment.html')
c = RequestContext(request, ctx)
return JsonResponse({'comment': t.render(c)})
return JsonResponseBadRequest({'msg': _("Comment submission failed.")})
def get_context_data(self, *args, **kwargs):
return {
"unit": self.object,
"form": self.get_unit_edit_form(),
"comment_form": self.get_unit_comment_form(),
"store": self.store,
"directory": self.directory,
"user": self.request.user,
"project": self.project,
"language": self.language,
"source_language": self.source_language,
"cantranslate": check_user_permission(
self.request.user, "translate", self.directory
),
"cantranslatexlang": check_user_permission(
self.request.user, "administrate", self.project.directory
),
"cansuggest": check_user_permission(
self.request.user, "suggest", self.directory
),
"canreview": check_user_permission(
self.request.user, "review", self.directory
),
"has_admin_access": check_user_permission(
self.request.user, "administrate", self.directory
),
"altsrcs": {x.id: x.data for x in self.get_alt_srcs()},
"unit_values": self.get_unit_values(),
"target_nplurals": self.get_target_nplurals(),
"has_plurals": self.object.hasplural(),
}
def save_comment(request, unit):
"""Stores a new comment for the given ``unit``.
:return: If the form validates, the cleaned comment is returned.
An error message is returned otherwise.
"""
# Update current unit instance's attributes
unit.commented_by = request.user
unit.commented_on = timezone.now().replace(microsecond=0)
language = request.translation_project.language
form = unit_comment_form_factory(language)(request.POST, instance=unit,
request=request)
if form.is_valid():
form.save()
user = request.user
directory = unit.store.parent
ctx = {
'unit': unit,
'language': language,
'cantranslate': check_user_permission(user, 'translate',
directory),
'cansuggest': check_user_permission(user, 'suggest', directory),
}
t = loader.get_template('editor/units/xhr_comment.html')
c = RequestContext(request, ctx)
return JsonResponse({'comment': t.render(c)})
return JsonResponseBadRequest({'msg': _("Comment submission failed.")})
def get_context_data(self, *args, **kwargs):
priority = (self.store.priority
if 'virtualfolder' in settings.INSTALLED_APPS else None)
suggestions = self.object.get_suggestions()
return {
'unit':
self.object,
'form':
self.get_unit_edit_form(),
'comment_form':
self.get_unit_comment_form(),
'priority':
priority,
'store':
self.store,
'directory':
self.directory,
'user':
self.request.user,
'project':
self.project,
'language':
self.language,
'special_characters':
self.special_characters,
'source_language':
self.source_language,
'cantranslate':
check_user_permission(self.request.user, "translate",
self.directory),
'cantranslatexlang':
check_user_permission(self.request.user, "administrate",
self.project.directory),
'cansuggest':
check_user_permission(self.request.user, "suggest",
self.directory),
'canreview':
check_user_permission(self.request.user, "review", self.directory),
'has_admin_access':
check_user_permission(self.request.user, 'administrate',
self.directory),
'altsrcs': {x.id: x.data
for x in self.get_alt_srcs()},
'unit_values':
self.get_unit_values(),
'target_nplurals':
self.get_target_nplurals(),
'has_plurals':
self.object.hasplural(),
'filetype':
self.object.store.filetype.name,
'suggestions':
suggestions,
'suggestions_dict': {
x.id: dict(id=x.id, target=x.target.strings)
for x in suggestions
},
}
def get_context_data(self, *args, **kwargs):
priority = (
self.store.priority
if 'virtualfolder' in settings.INSTALLED_APPS
else None)
suggestions = self.object.get_suggestions()
latest_target_submission = self.object.get_latest_target_submission()
accepted_suggestion = None
if latest_target_submission is not None:
accepted_suggestion = latest_target_submission.suggestion
critical_checks = list(self.object.get_critical_qualitychecks())
failing_checks = any(
not check.false_positive
for check
in critical_checks)
return {
'unit': self.object,
'accepted_suggestion': accepted_suggestion,
'form': self.get_unit_edit_form(),
'comment_form': self.get_unit_comment_form(),
'priority': priority,
'store': self.store,
'directory': self.directory,
'user': self.request.user,
'project': self.project,
'language': self.language,
'special_characters': self.special_characters,
'source_language': self.source_language,
'cantranslate': check_user_permission(self.request.user,
"translate",
self.directory),
'cantranslatexlang': check_user_permission(self.request.user,
"administrate",
self.project.directory),
'cansuggest': check_user_permission(self.request.user,
"suggest",
self.directory),
'canreview': check_user_permission(self.request.user,
"review",
self.directory),
'has_admin_access': check_user_permission(self.request.user,
'administrate',
self.directory),
'altsrcs': {x.id: x.data for x in self.get_alt_srcs()},
'unit_values': self.get_unit_values(),
'target_nplurals': self.get_target_nplurals(),
'has_plurals': self.object.hasplural(),
'filetype': self.object.store.filetype.name,
'suggestions': suggestions,
'suggestions_dict': {x.id: dict(id=x.id, target=x.target.strings)
for x in suggestions},
"failing_checks": failing_checks,
"critical_checks": critical_checks,
"warning_checks": list(
self.object.get_warning_qualitychecks()),
"terms": self.object.get_terminology()}
def test_get_edit_unit(project0_nongnu, get_edit_unit, client,
request_users, settings):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
unit = get_edit_unit
store = unit.store
filetype = unit.store.filetype.name
directory = store.parent
translation_project = store.translation_project
project = translation_project.project
language = translation_project.language
response = client.get(
"/xhr/units/%s/edit/" % unit.id,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
request = response.wsgi_request
result = json.loads(response.content)
src_lang = unit.store.translation_project.project.source_language
alt_src_langs = get_alt_src_langs(request, user, translation_project)
altsrcs = find_altsrcs(unit, alt_src_langs, store=store, project=project)
altsrcs = {x.id: x.data for x in altsrcs}
sources = {altsrcs[x]['language_code']: altsrcs[x]['target'] for x in altsrcs}
sources[src_lang.code] = unit.source
assert result["is_obsolete"] is False
assert result["sources"] == sources
assert response.context["unit"] == unit
assert response.context["priority"] == store.priority
assert response.context["store"] == store
assert response.context["filetype"] == filetype
assert response.context["directory"] == directory
assert response.context["project"] == project
assert response.context["language"] == language
assert response.context["source_language"] == src_lang
assert response.context["altsrcs"] == altsrcs
assert response.context["cantranslate"] == check_user_permission(
user, "translate", directory)
assert response.context["cansuggest"] == check_user_permission(
user, "suggest", directory)
assert response.context["canreview"] == check_user_permission(
user, "review", directory)
assert response.context["has_admin_access"] == check_user_permission(
user, "administrate", directory)
def get_browsing_data(self):
browsing_data = remove_empty_from_dict(
self.get_item_data(self.object, self.stats)
)
has_admin_access = check_user_permission(
self.request.user, "administrate", self.permission_context
)
if "total" not in browsing_data and not has_admin_access:
raise Http404
children_stats = self.stats["children"]
browsing_data.update(
{
"children": {
path: remove_empty_from_dict(data)
for path, data in (
self.get_item_data_tuple(item, children_stats[i])
for i, item in enumerate(self.items)
)
if (
(data["total"] is not None and data["total"] > 0)
or has_admin_access
)
},
}
)
return browsing_data
def get_users_with_permission(self, permission_code, project, language):
default = self.get_default_user()
directory = TranslationProject.objects.get(
project=project,
language=language
).directory
if check_user_permission(default, permission_code, directory):
return self.hide_meta().filter(is_active=True)
user_filter = Q(
permissionset__positive_permissions__codename=permission_code
)
language_path = language.directory.pootle_path
project_path = project.directory.pootle_path
user_filter &= (
Q(permissionset__directory__pootle_path=directory.pootle_path)
| Q(permissionset__directory__pootle_path=language_path)
| Q(permissionset__directory__pootle_path=project_path)
)
user_filter |= Q(is_superuser=True)
return self.get_queryset().filter(user_filter).distinct()
def test_import_add_and_obsolete_units(project0_nongnu, import_tps,
site_users):
from pytest_pootle.factories import StoreDBFactory, UnitDBFactory
tp = import_tps
user = site_users["user"]
store = StoreDBFactory(translation_project=tp)
unit = UnitDBFactory(store=store, state=TRANSLATED)
filestore = create_store(
store.pootle_path,
"0",
[(unit.source_f + " REPLACED", unit.target_f + " REPLACED", False)])
import_file(SimpleUploadedFile("import_add_and_obsolete.po",
str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
if allow_add_and_obsolete:
assert Unit.objects.filter(store=store, state=OBSOLETE).count() == 1
assert store.units.filter(state=TRANSLATED).count() == 1
unit_source = store.units[0].unit_source
assert unit_source.created_with == SubmissionTypes.UPLOAD
assert unit_source.created_by == user
assert store.units[0].change.changed_with == SubmissionTypes.UPLOAD
assert store.units[0].change.submitted_by == user
assert Unit.objects.filter(store=store).count() == 2
else:
assert store.units.all().count() == 1
def get_users_with_permission(self,
permission_code,
project,
language,
tp=None):
default = self.get_default_user()
tp = (tp or TranslationProject.objects.get(project=project,
language=language))
directory = tp.directory
if check_user_permission(default, permission_code, directory):
return self.hide_meta().filter(is_active=True)
user_filter = Q(
permissionset__positive_permissions__codename=permission_code)
user_filter &= (
Q(permissionset__directory__pootle_path=directory.pootle_path)
| Q(permissionset__directory__pootle_path=language.pootle_path)
| Q(permissionset__directory__pootle_path=project.pootle_path))
user_filter |= Q(is_superuser=True)
return self.get_queryset().filter(user_filter).distinct()
def test_import_to_empty(project0_nongnu, import_tps, site_users):
from pytest_pootle.factories import StoreDBFactory
tp = import_tps
user = site_users["user"]
store = StoreDBFactory(translation_project=tp, name="import_to_empty.po")
filestore = create_store(store.pootle_path, "0",
[("Unit Source", "Unit Target", False)])
import_file(SimpleUploadedFile(store.name,
str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
if allow_add_and_obsolete:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 1
unit_source = store.units[0].unit_source
assert unit_source.created_with == SubmissionTypes.UPLOAD
assert unit_source.created_by == user
assert store.units[0].change.changed_with == SubmissionTypes.UPLOAD
assert store.units[0].change.submitted_by == user
else:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 0
def test_get_edit_unit(client, request_users, settings):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
unit = Unit.objects.get_translatable(user).first()
store = unit.store
directory = store.parent
translation_project = store.translation_project
project = translation_project.project
language = translation_project.language
response = client.get(
"/xhr/units/%s/edit/" % unit.id,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
request = response.wsgi_request
result = json.loads(response.content)
src_lang = unit.store.translation_project.project.source_language
alt_src_langs = get_alt_src_langs(request, user, translation_project)
altsrcs = find_altsrcs(unit, alt_src_langs, store=store, project=project)
assert result["is_obsolete"] is False
assert result["sources"] == {src_lang.code: unit.source}
assert response.context["unit"] == unit
assert response.context["priority"] == unit.priority
assert response.context["store"] == store
assert response.context["directory"] == directory
assert response.context["project"] == project
assert response.context["language"] == language
assert response.context["source_language"] == src_lang
assert response.context["altsrcs"] == altsrcs
assert response.context["cantranslate"] == check_user_permission(
user, "translate", directory)
assert response.context["cansuggest"] == check_user_permission(
user, "suggest", directory)
assert response.context["canreview"] == check_user_permission(
user, "review", directory)
assert response.context["has_admin_access"] == check_user_permission(
user, "administrate", directory)
def test_get_edit_unit(client, request_users, settings):
user = request_users["user"]
if user.username != "nobody":
client.login(username=user.username,
password=request_users["password"])
unit = Unit.objects.get_translatable(user).first()
store = unit.store
directory = store.parent
translation_project = store.translation_project
project = translation_project.project
language = translation_project.language
response = client.get("/xhr/units/%s/edit/" % unit.id,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
request = response.wsgi_request
result = json.loads(response.content)
src_lang = unit.store.translation_project.project.source_language
alt_src_langs = get_alt_src_langs(request, user, translation_project)
altsrcs = find_altsrcs(unit, alt_src_langs, store=store, project=project)
assert result["is_obsolete"] is False
assert result["sources"] == {src_lang.code: unit.source}
assert response.context["unit"] == unit
assert response.context["priority"] == unit.priority
assert response.context["store"] == store
assert response.context["directory"] == directory
assert response.context["project"] == project
assert response.context["language"] == language
assert response.context["source_language"] == src_lang
assert response.context["altsrcs"] == altsrcs
assert response.context["cantranslate"] == check_user_permission(
user, "translate", directory)
assert response.context["cansuggest"] == check_user_permission(
user, "suggest", directory)
assert response.context["canreview"] == check_user_permission(
user, "review", directory)
assert response.context["has_admin_access"] == check_user_permission(
user, "administrate", directory)
def _check_path_permission(self, path, user):
ctx_obj = self._get_ctx_obj(path, user)
if ctx_obj is None:
raise Http404
can_admin_path = check_user_permission(user, "administrate", ctx_obj.directory)
if not can_admin_path:
return False
return True
def get_context_data(self, *args, **kwargs):
priority = (
self.store.priority
if 'virtualfolder' in settings.INSTALLED_APPS
else None)
suggestions = self.object.get_suggestions()
return {
'unit': self.object,
'form': self.get_unit_edit_form(),
'comment_form': self.get_unit_comment_form(),
'priority': priority,
'store': self.store,
'directory': self.directory,
'user': self.request.user,
'project': self.project,
'language': self.language,
'special_characters': self.special_characters,
'source_language': self.source_language,
'cantranslate': check_user_permission(self.request.user,
"translate",
self.directory),
'cantranslatexlang': check_user_permission(self.request.user,
"administrate",
self.project.directory),
'cansuggest': check_user_permission(self.request.user,
"suggest",
self.directory),
'canreview': check_user_permission(self.request.user,
"review",
self.directory),
'has_admin_access': check_user_permission(self.request.user,
'administrate',
self.directory),
'altsrcs': {x.id: x.data for x in self.get_alt_srcs()},
'unit_values': self.get_unit_values(),
'target_nplurals': self.get_target_nplurals(),
'has_plurals': self.object.hasplural(),
'filetype': self.object.store.filetype.name,
'suggestions': suggestions,
'suggestions_dict': {x.id: dict(id=x.id, target=x.target.strings)
for x in suggestions},
}
def get_context_data(self, *args, **kwargs):
priority = self.object.priority if "virtualfolder" in settings.INSTALLED_APPS else None
return {
"unit": self.object,
"form": self.get_unit_edit_form(),
"comment_form": self.get_unit_comment_form(),
"priority": priority,
"store": self.store,
"directory": self.directory,
"user": self.request.user,
"project": self.project,
"language": self.language,
"source_language": self.source_language,
"cantranslate": check_user_permission(self.request.user, "translate", self.directory),
"cantranslatexlang": check_user_permission(self.request.user, "administrate", self.project.directory),
"cansuggest": check_user_permission(self.request.user, "suggest", self.directory),
"canreview": check_user_permission(self.request.user, "review", self.directory),
"has_admin_access": check_user_permission(self.request.user, "administrate", self.directory),
"altsrcs": self.get_alt_srcs(),
}
def clean(self):
self_review = (self.request_user == self.target_object.user
and self.cleaned_data.get("action") == "reject")
permission = ("view" if self_review else "review")
has_permission = check_user_permission(
self.request_user, permission,
self.target_object.unit.store.parent)
if not has_permission:
raise forms.ValidationError(
_("Insufficient rights to access this page."))
if not self.errors:
super(SuggestionReviewForm, self).clean()
def render_latest_news(context, path, num):
try:
directory = Directory.objects.get(pootle_path='/%s' % path)
user = context['user']
can_view = check_user_permission(user, "view", directory)
if not can_view:
directory = None
except Directory.DoesNotExist:
directory = None
if directory is None:
return {'news_items': None}
news_items = Notice.objects.filter(directory=directory)[:num]
return {'news_items': news_items}
def test_get_units(get_units_views):
(user, search_params, url_params, response) = get_units_views
result = json.loads(response.content)
path = parse_qs(url_params)["path"][0]
permission_context = None
if path.strip("/") in ["", "projects"]:
permission_context = Directory.objects.get(pootle_path="/projects/")
elif path.startswith("/projects/"):
try:
permission_context = Project.objects.get(
code=path[10:].split("/")[0]).directory
except Project.DoesNotExist:
assert response.status_code == 404
assert "unitGroups" not in result
return
user_cannot_view = (
permission_context
and not check_user_permission(
user, "administrate", permission_context))
if user_cannot_view:
assert response.status_code == 404
assert "unitGroups" not in result
return
assert "unitGroups" in result
assert isinstance(result["unitGroups"], list)
for k in "start", "end", "total":
assert k in result
assert isinstance(result[k], int)
if result["unitGroups"]:
total, start, end, expected_units = calculate_search_results(
search_params, user)
assert result["total"] == total
assert result["start"] == start
assert result["end"] == end
for i, group in enumerate(expected_units):
result_group = result["unitGroups"][i]
for store, data in group.items():
result_data = result_group[store]
assert (
[u["id"] for u in result_data["units"]]
== [u["id"] for u in data["units"]])
def test_get_units(get_units_views):
(user, search_params, url_params, response) = get_units_views
result = json.loads(response.content)
path = parse_qs(url_params)["path"][0]
permission_context = None
if path.strip("/") in ["", "projects"]:
permission_context = Directory.objects.get(pootle_path="/projects/")
elif path.startswith("/projects/"):
try:
permission_context = Project.objects.get(
code=path[10:].split("/")[0]).directory
except Project.DoesNotExist:
assert response.status_code == 404
assert "unitGroups" not in result
return
user_cannot_view = (
permission_context
and not check_user_permission(
user, "administrate", permission_context))
if user_cannot_view:
assert response.status_code == 404
assert "unitGroups" not in result
return
assert "unitGroups" in result
assert isinstance(result["unitGroups"], list)
for k in "start", "end", "total":
assert k in result
assert isinstance(result[k], int)
if result["unitGroups"]:
total, start, end, expected_units = calculate_search_results(
search_params, user)
assert result["total"] == total
assert result["start"] == start
assert result["end"] == end
for i, group in enumerate(expected_units):
result_group = result["unitGroups"][i]
for store, data in group.items():
result_data = result_group[store]
assert (
[u["id"] for u in result_data["units"]]
== [u["id"] for u in data["units"]])
def _get_critical_checks_snippet(request, unit):
"""Retrieves the critical checks snippet.
:param request: an `HttpRequest` object
:param unit: a `Unit` instance for which critical checks need to be
rendered.
:return: rendered HTML snippet with the failing checks, or `None` if
there are no critical failing checks.
"""
if not unit.has_critical_checks():
return None
can_review = check_user_permission(request.user, "review", unit.store.parent)
ctx = {"canreview": can_review, "unit": unit}
template = loader.get_template("editor/units/xhr_checks.html")
return template.render(RequestContext(request, ctx))
def get_recipients(restrict_to_active_users, directory):
to_list = PootleProfile.objects.all()
# Take into account 'only active users' flag from the form.
if restrict_to_active_users:
to_list = to_list.exclude(submission=None).exclude(suggestions=None)
recipients = []
for person in to_list:
# Check if the User profile has permissions in the directory.
if not check_user_permission(person.user, "view", directory, check_default=False):
continue
if person.user.email:
recipients.append(person.user.email)
return recipients
def clean(self):
self_review = (
self.request_user == self.target_object.user
and self.cleaned_data.get("action") == "reject")
permission = (
"view"
if self_review
else "review")
has_permission = check_user_permission(
self.request_user,
permission,
self.target_object.unit.store.parent)
if not has_permission:
raise forms.ValidationError(
_("Insufficient rights to access this page."))
if not self.errors:
super(SuggestionReviewForm, self).clean()
def import_file(f, user=None):
ttk = getclass(f)(f.read())
if not hasattr(ttk, "parseheader"):
raise UnsupportedFiletypeError(
_(
"Unsupported filetype '%s', only PO "
"files are supported at this time\n", f.name))
header = ttk.parseheader()
pootle_path = header.get("X-Pootle-Path")
if not pootle_path:
raise MissingPootlePathError(
_("File '%s' missing X-Pootle-Path "
"header\n", f.name))
rev = header.get("X-Pootle-Revision")
if not rev or not rev.isdigit():
raise MissingPootleRevError(
_("File '%s' missing or invalid "
"X-Pootle-Revision header\n", f.name))
rev = int(rev)
try:
store = Store.objects.get(pootle_path=pootle_path)
except Store.DoesNotExist as e:
raise FileImportError(
_(
"Could not create '%(filename)s'. Missing "
"Project/Language? (%(error)s)", dict(filename=f.name,
error=e)))
tp = store.translation_project
allow_add_and_obsolete = (
(tp.project.checkstyle == 'terminology' or tp.is_template_project)
and check_user_permission(user, 'administrate', tp.directory))
try:
store.update(store=ttk,
user=user,
submission_type=SubmissionTypes.UPLOAD,
store_revision=rev,
allow_add_and_obsolete=allow_add_and_obsolete)
except Exception as e:
# This should not happen!
logger.error("Error importing file: %s", str(e))
raise FileImportError(_("There was an error uploading your file"))
def test_import_to_empty(import_tps, site_users):
from pytest_pootle.factories import StoreFactory
tp = import_tps
user = site_users["user"]
store = StoreFactory(translation_project=tp, name="import_to_empty.po")
filestore = create_store(store.pootle_path, "0",
[("Unit Source", "Unit Target")])
import_file(
SimpleUploadedFile(store.name, str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = (
(tp.project.checkstyle == 'terminology' or tp.is_template_project)
and check_user_permission(user, 'administrate', tp.directory))
if allow_add_and_obsolete:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 1
else:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 0
def _get_critical_checks_snippet(request, unit):
"""Retrieves the critical checks snippet.
:param request: an `HttpRequest` object
:param unit: a `Unit` instance for which critical checks need to be
rendered.
:return: rendered HTML snippet with the failing checks, or `None` if
there are no critical failing checks.
"""
if not unit.has_critical_checks():
return None
can_review = check_user_permission(request.user, "review", unit.store.parent)
ctx = {
"canreview": can_review,
"unit": unit,
}
template = loader.get_template("editor/units/xhr_checks.html")
return template.render(context=ctx, request=request)
def get_recipients(restrict_to_active_users, directory):
User = get_user_model()
to_list = User.objects.all()
# Take into account 'only active users' flag from the form.
if restrict_to_active_users:
to_list = to_list.exclude(submission=None).exclude(suggestions=None)
recipients = []
for user in to_list:
# Check if the User has permissions in the directory.
if not check_user_permission(
user, "view", directory, check_default=False):
continue
if user.email:
recipients.append(user.email)
return recipients
def import_file(f, user=None):
ttk = getclass(f)(f.read())
if not hasattr(ttk, "parseheader"):
raise UnsupportedFiletypeError(_("Unsupported filetype '%s', only PO "
"files are supported at this time\n",
f.name))
header = ttk.parseheader()
pootle_path = header.get("X-Pootle-Path")
if not pootle_path:
raise MissingPootlePathError(_("File '%s' missing X-Pootle-Path "
"header\n", f.name))
rev = header.get("X-Pootle-Revision")
if not rev or not rev.isdigit():
raise MissingPootleRevError(_("File '%s' missing or invalid "
"X-Pootle-Revision header\n",
f.name))
rev = int(rev)
try:
store = Store.objects.get(pootle_path=pootle_path)
except Store.DoesNotExist as e:
raise FileImportError(
_("Could not create '%(filename)s'. Missing "
"Project/Language? (%(error)s)",
dict(filename=f.name, error=e)))
tp = store.translation_project
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
try:
store.update(store=ttk, user=user,
submission_type=SubmissionTypes.UPLOAD,
store_revision=rev,
allow_add_and_obsolete=allow_add_and_obsolete)
except Exception as e:
# This should not happen!
logger.error("Error importing file: %s", str(e))
raise FileImportError(_("There was an error uploading your file"))
def _get_critical_checks_snippet(request, unit):
"""Retrieves the critical checks snippet.
:param request: an `HttpRequest` object
:param unit: a `Unit` instance for which critical checks need to be
rendered.
:return: rendered HTML snippet with the failing checks, or `None` if
there are no critical failing checks.
"""
if not unit.has_critical_checks():
return None
can_review = check_user_permission(request.profile, 'review',
unit.store.parent)
ctx = {
'canreview': can_review,
'unit': unit,
}
template = loader.get_template('editor/units/xhr_checks.html')
return template.render(RequestContext(request, ctx))
def test_get_users_with_permission(default, member, translate):
language = Language.objects.get(code="language0")
project = Project.objects.get(code="project0")
User = get_user_model()
directory = TranslationProject.objects.get(project=project,
language=language).directory
_require_permission_set(member, directory, [translate])
# remove "Can submit translation" permission for default user
ps = PermissionSet.objects.filter(user=default,
directory=Directory.objects.root)[0]
ps.positive_permissions.set(
ps.positive_permissions.exclude(id=translate.id))
ps.save()
users = User.objects.get_users_with_permission("translate", project,
language)
for user in users:
assert check_user_permission(user, "translate", directory)
def clean_path(self):
lang_code, proj_code = split_pootle_path(self.cleaned_data["path"])[:2]
if not (lang_code or proj_code):
permission_context = Directory.objects.projects
elif proj_code and not lang_code:
try:
permission_context = Project.objects.select_related(
"directory").get(code=proj_code).directory
except Project.DoesNotExist:
raise forms.ValidationError("Unrecognized path")
else:
# no permission checking on lang translate views
return self.cleaned_data["path"]
if self.request_user.is_superuser:
return self.cleaned_data["path"]
can_view_path = check_user_permission(self.request_user,
"administrate",
permission_context)
if can_view_path:
return self.cleaned_data["path"]
raise forms.ValidationError("Unrecognized path")
def test_import_to_empty(import_tps, site_users):
from pytest_pootle.factories import StoreFactory
tp = import_tps
user = site_users["user"]
store = StoreFactory(translation_project=tp, name="import_to_empty.po")
filestore = create_store(store.pootle_path, "0",
[("Unit Source", "Unit Target")])
import_file(SimpleUploadedFile(store.name,
str(filestore),
"text/x-gettext-translation"), user)
allow_add_and_obsolete = ((tp.project.checkstyle == 'terminology'
or tp.is_template_project)
and check_user_permission(user,
'administrate',
tp.directory))
if allow_add_and_obsolete:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 1
else:
assert tp.stores.get(pootle_path=store.pootle_path).units.count() == 0
def clean_path(self):
language_code, project_code = split_pootle_path(
self.cleaned_data["path"])[:2]
if not (language_code or project_code):
permission_context = Directory.objects.projects
elif project_code and not language_code:
try:
permission_context = Project.objects.select_related(
"directory").get(code=project_code).directory
except Project.DoesNotExist:
raise forms.ValidationError("Unrecognized path")
else:
# no permission checking on lang translate views
return self.cleaned_data["path"]
if self.request_user.is_superuser:
return self.cleaned_data["path"]
can_view_path = check_user_permission(
self.request_user, "administrate", permission_context)
if can_view_path:
return self.cleaned_data["path"]
raise forms.ValidationError("Unrecognized path")
def get_browsing_data(self):
browsing_data = remove_empty_from_dict({
key: value
for key, value in self.stats.iteritems() if key != 'children'
})
has_admin_access = check_user_permission(self.request.user,
'administrate',
self.permission_context)
if 'total' not in browsing_data and not has_admin_access:
raise Http404
children_stats = self.stats['children']
browsing_data.update({
'children': {
path: remove_empty_from_dict(data)
for path, data in (self.get_item_data(item, children_stats[i])
for i, item in enumerate(self.items))
if data['total'] > 0 or has_admin_access
},
})
return browsing_data
def _get_critical_checks_snippet(request, unit):
"""Retrieves the critical checks snippet.
:param request: an `HttpRequest` object
:param unit: a `Unit` instance for which critical checks need to be
rendered.
:return: rendered HTML snippet with the failing checks, or `None` if
there are no critical failing checks.
"""
if not unit.has_critical_checks():
return None
can_review = check_user_permission(request.user, 'review',
unit.store.parent)
ctx = {
'canreview': can_review,
'unit': unit,
'critical_checks': list(unit.get_critical_qualitychecks()),
'warning_checks': list(unit.get_warning_qualitychecks()),
}
template = loader.get_template('editor/units/xhr_checks.html')
return template.render(context=ctx, request=request)
def test_get_users_with_permission(default, member, translate):
language = Language.objects.get(code='language0')
project = Project.objects.get(code='project0')
User = get_user_model()
directory = TranslationProject.objects.get(
project=project,
language=language
).directory
member.email = "*****@*****.**"
member.save()
accounts.utils.verify_user(member)
_require_permission_set(member, directory, [translate])
# remove "Can submit translation" permission for default user
ps = PermissionSet.objects.filter(user=default,
directory=Directory.objects.root)[0]
ps.positive_permissions.set(ps.positive_permissions.exclude(id=translate.id))
ps.save()
users = User.objects.get_users_with_permission('translate', project, language)
for user in users:
assert check_user_permission(user, 'translate', directory)
def test_get_users_with_permission(default, member, translate):
language = Language.objects.get(code='language0')
project = Project.objects.get(code='project0')
User = get_user_model()
directory = TranslationProject.objects.get(project=project,
language=language).directory
member.email = "*****@*****.**"
member.save()
accounts.utils.verify_user(member)
_require_permission_set(member, directory, [translate])
# remove "Can submit translation" permission for default user
ps = PermissionSet.objects.filter(user=default,
directory=Directory.objects.root)[0]
ps.positive_permissions.set(
ps.positive_permissions.exclude(id=translate.id))
ps.save()
users = User.objects.get_users_with_permission('translate', project,
language)
for user in users:
assert check_user_permission(user, 'translate', directory)
def _get_critical_checks_snippet(request, unit):
"""Retrieves the critical checks snippet.
:param request: an `HttpRequest` object
:param unit: a `Unit` instance for which critical checks need to be
rendered.
:return: rendered HTML snippet with the failing checks, or `None` if
there are no critical failing checks.
"""
has_critical_checks = unit.qualitycheck_set.filter(
category=Category.CRITICAL,
).exists()
if not has_critical_checks:
return None
can_review = check_user_permission(request.profile, 'review',
unit.store.parent)
ctx = {
'canreview': can_review,
'unit': unit,
}
template = loader.get_template('editor/units/xhr_checks.html')
return template.render(RequestContext(request, ctx))
def test_get_edit_unit(project0_nongnu, get_edit_unit, client, request_users,
settings):
user = request_users["user"]
if user.username != "nobody":
client.login(username=user.username,
password=request_users["password"])
unit = get_edit_unit
store = unit.store
filetype = unit.store.filetype.name
directory = store.parent
translation_project = store.translation_project
project = translation_project.project
language = translation_project.language
response = client.get("/xhr/units/%s/edit/" % unit.id,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
request = response.wsgi_request
result = json.loads(response.content)
special_characters = []
for specialchar in language.specialchars:
code = ord(specialchar)
special_characters.append({
'display':
CHARACTERS_NAMES.get(code, specialchar),
'code':
code,
'hex_code':
"U+" + hex(code)[2:].upper(),
'name':
unicodedata.name(specialchar, ''),
})
src_lang = unit.store.translation_project.project.source_language
alt_src_langs = get_alt_src_langs(request, user, translation_project)
altsrcs = find_altsrcs(unit, alt_src_langs, store=store, project=project)
altsrcs = {x.id: x.data for x in altsrcs}
sources = {
altsrcs[x]['language_code']: altsrcs[x]['target']
for x in altsrcs
}
sources[src_lang.code] = unit.source
suggestions_dict = {
x.id: dict(id=x.id, target=x.target.strings)
for x in unit.get_suggestions()
}
assert result["is_obsolete"] is False
assert result["sources"] == sources
assert response.context["unit"] == unit
assert response.context["priority"] == store.priority
assert response.context["store"] == store
assert response.context["filetype"] == filetype
assert response.context["directory"] == directory
assert response.context["project"] == project
assert response.context["language"] == language
assert response.context["special_characters"] == special_characters
assert response.context["source_language"] == src_lang
assert response.context["altsrcs"] == altsrcs
assert response.context["suggestions_dict"] == suggestions_dict
assert response.context["cantranslate"] == check_user_permission(
user, "translate", directory)
assert response.context["cansuggest"] == check_user_permission(
user, "suggest", directory)
assert response.context["canreview"] == check_user_permission(
user, "review", directory)
assert response.context["has_admin_access"] == check_user_permission(
user, "administrate", directory)
def submit(request, unit):
"""Processes translation submissions and stores them in the database.
:return: An object in JSON notation that contains the previous and last
units for the unit next to unit ``uid``.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
# Store current time so that it is the same for all submissions
current_time = timezone.now()
form_class = unit_form_factory(language, snplurals, request)
form = form_class(request.POST, instance=unit, request=request)
if form.is_valid():
if form.updated_fields:
for field, old_value, new_value in form.updated_fields:
sub = Submission(
creation_time=current_time,
translation_project=translation_project,
submitter=request.profile,
unit=unit,
store=unit.store,
field=field,
type=SubmissionTypes.NORMAL,
old_value=old_value,
new_value=new_value,
similarity=form.cleaned_data['similarity'],
mt_similarity=form.cleaned_data['mt_similarity'],
)
sub.save()
# Update current unit instance's attributes
# important to set these attributes after saving Submission
# because we need to access the unit's state before it was saved
if SubmissionFields.TARGET in \
map(lambda x: x[0], form.updated_fields):
form.instance.submitted_by = request.profile
form.instance.submitted_on = current_time
form.instance.reviewed_by = None
form.instance.reviewed_on = None
form.instance._log_user = request.profile
form.save()
translation_submitted.send(
sender=translation_project,
unit=form.instance,
profile=request.profile,
)
has_critical_checks = unit.qualitycheck_set.filter(
category=Category.CRITICAL).exists()
if has_critical_checks:
can_review = check_user_permission(request.profile, 'review',
unit.store.parent)
ctx = {'canreview': can_review, 'unit': unit}
template = loader.get_template('editor/units/xhr_checks.html')
context = RequestContext(request, ctx)
json['checks'] = template.render(context)
rcode = 200
json['user_score'] = request.profile.public_score
else:
# Form failed
#FIXME: we should display validation errors here
rcode = 400
json["msg"] = _("Failed to process submission.")
response = jsonify(json)
return HttpResponse(response,
status=rcode,
content_type="application/json")
def get_edit_unit(request, unit):
"""Given a store path ``pootle_path`` and unit id ``uid``, gathers all the
necessary information to build the editing widget.
:return: A templatised editing widget is returned within the ``editor``
variable and paging information is also returned if the page
number has changed.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(instance=unit, request=request)
comment_form_class = unit_comment_form_factory(language)
comment_form = comment_form_class({}, instance=unit, request=request)
store = unit.store
directory = store.parent
user = request.profile
alt_src_langs = get_alt_src_langs(request, user, translation_project)
project = translation_project.project
template_vars = {
'unit': unit,
'form': form,
'comment_form': comment_form,
'store': store,
'directory': directory,
'profile': user,
'user': request.user,
'project': project,
'language': language,
'source_language': translation_project.project.source_language,
'cantranslate': check_user_permission(user, "translate", directory),
'cansuggest': check_user_permission(user, "suggest", directory),
'canreview': check_user_permission(user, "review", directory),
'is_admin': check_user_permission(user, 'administrate', directory),
'altsrcs': find_altsrcs(unit,
alt_src_langs,
store=store,
project=project),
}
if translation_project.project.is_terminology or store.is_terminology:
t = loader.get_template('editor/units/term_edit.html')
else:
t = loader.get_template('editor/units/edit.html')
c = RequestContext(request, template_vars)
json['editor'] = t.render(c)
json['tm_suggestions'] = unit.get_tm_suggestions()
json['is_obsolete'] = unit.isobsolete()
rcode = 200
# Return context rows if filtering is applied but
# don't return any if the user has asked not to have it
current_filter = request.GET.get('filter', 'all')
show_ctx = request.COOKIES.get('ctxShow', 'true')
if ((_is_filtered(request) or current_filter not in ('all', ))
and show_ctx == 'true'):
# TODO: review if this first 'if' branch makes sense
if translation_project.project.is_terminology or store.is_terminology:
json['ctx'] = _filter_ctx_units(store.units, unit, 0)
else:
ctx_qty = int(request.COOKIES.get('ctxQty', 1))
json['ctx'] = _filter_ctx_units(store.units, unit, ctx_qty)
response = jsonify(json)
return HttpResponse(response,
status=rcode,
content_type="application/json")
def get_edit_unit(request, unit):
"""Given a store path ``pootle_path`` and unit id ``uid``, gathers all the
necessary information to build the editing widget.
:return: A templatised editing widget is returned within the ``editor``
variable and paging information is also returned if the page
number has changed.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(instance=unit, request=request)
comment_form_class = unit_comment_form_factory(language)
comment_form = comment_form_class({}, instance=unit, request=request)
store = unit.store
directory = store.parent
user = request.profile
alt_src_langs = get_alt_src_langs(request, user, translation_project)
project = translation_project.project
priority = None
if "virtualfolder" in settings.INSTALLED_APPS:
vfolder_pk = request.GET.get("vfolder", "")
if vfolder_pk:
from virtualfolder.models import VirtualFolder
try:
# If we are translating a virtual folder, then display its
# priority.
# Note that the passed virtual folder pk might be invalid.
priority = VirtualFolder.objects.get(pk=vfolder_pk).priority
except VirtualFolder.DoesNotExist:
pass
if priority is None:
# Retrieve the unit top priority, if any. This can happen if we are
# not in a virtual folder or if the passed virtual folder pk is
# invalid.
priority = unit.vfolders.aggregate(priority=Max("priority"))["priority"]
template_vars = {
"unit": unit,
"form": form,
"comment_form": comment_form,
"priority": priority,
"store": store,
"directory": directory,
"profile": user,
"user": request.user,
"project": project,
"language": language,
"source_language": translation_project.project.source_language,
"cantranslate": check_user_permission(user, "translate", directory),
"cansuggest": check_user_permission(user, "suggest", directory),
"canreview": check_user_permission(user, "review", directory),
"is_admin": check_user_permission(user, "administrate", directory),
"altsrcs": find_altsrcs(unit, alt_src_langs, store=store, project=project),
}
if translation_project.project.is_terminology or store.is_terminology:
t = loader.get_template("editor/units/term_edit.html")
else:
t = loader.get_template("editor/units/edit.html")
c = RequestContext(request, template_vars)
json["editor"] = t.render(c)
json["tm_suggestions"] = unit.get_tm_suggestions()
json["is_obsolete"] = unit.isobsolete()
return JsonResponse(json)
def get_edit_unit(request, unit):
"""Given a store path ``pootle_path`` and unit id ``uid``, gathers all the
necessary information to build the editing widget.
:return: A templatised editing widget is returned within the ``editor``
variable and paging information is also returned if the page
number has changed.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(instance=unit, request=request)
comment_form_class = unit_comment_form_factory(language)
comment_form = comment_form_class({}, instance=unit, request=request)
store = unit.store
directory = store.parent
user = request.profile
alt_src_langs = get_alt_src_langs(request, user, translation_project)
project = translation_project.project
priority = None
if 'virtualfolder' in settings.INSTALLED_APPS:
vfolder_pk = request.GET.get('vfolder', '')
if vfolder_pk:
from virtualfolder.models import VirtualFolder
try:
# If we are translating a virtual folder, then display its
# priority.
# Note that the passed virtual folder pk might be invalid.
priority = VirtualFolder.objects.get(pk=vfolder_pk).priority
except VirtualFolder.DoesNotExist:
pass
if priority is None:
# Retrieve the unit top priority, if any. This can happen if we are
# not in a virtual folder or if the passed virtual folder pk is
# invalid.
priority = unit.vfolders.aggregate(
priority=Max('priority')
)['priority']
template_vars = {
'unit': unit,
'form': form,
'comment_form': comment_form,
'priority': priority,
'store': store,
'directory': directory,
'profile': user,
'user': request.user,
'project': project,
'language': language,
'source_language': translation_project.project.source_language,
'cantranslate': check_user_permission(user, "translate", directory),
'cansuggest': check_user_permission(user, "suggest", directory),
'canreview': check_user_permission(user, "review", directory),
'is_admin': check_user_permission(user, 'administrate', directory),
'altsrcs': find_altsrcs(unit, alt_src_langs, store=store,
project=project),
}
if translation_project.project.is_terminology or store.is_terminology:
t = loader.get_template('editor/units/term_edit.html')
else:
t = loader.get_template('editor/units/edit.html')
c = RequestContext(request, template_vars)
json['editor'] = t.render(c)
json['tm_suggestions'] = unit.get_tm_suggestions()
json['is_obsolete'] = unit.isobsolete()
# Return context rows if filtering is applied but
# don't return any if the user has asked not to have it
current_filter = request.GET.get('filter', 'all')
show_ctx = request.COOKIES.get('ctxShow', 'true')
if ((_is_filtered(request) or current_filter not in ('all',)) and
show_ctx == 'true'):
# TODO: review if this first 'if' branch makes sense
if translation_project.project.is_terminology or store.is_terminology:
json['ctx'] = _filter_ctx_units(store.units, unit, 0)
else:
ctx_qty = int(request.COOKIES.get('ctxQty', 1))
json['ctx'] = _filter_ctx_units(store.units, unit, ctx_qty)
return JsonResponse(json)
def get_edit_unit(request, unit):
"""Given a store path ``pootle_path`` and unit id ``uid``, gathers all the
necessary information to build the editing widget.
:return: A templatised editing widget is returned within the ``editor``
variable and paging information is also returned if the page
number has changed.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(instance=unit, request=request)
comment_form_class = unit_comment_form_factory(language)
comment_form = comment_form_class({}, instance=unit, request=request)
store = unit.store
directory = store.parent
user = request.profile
alt_src_langs = get_alt_src_langs(request, user, translation_project)
project = translation_project.project
priority = None
if 'virtualfolder' in settings.INSTALLED_APPS:
vfolder_pk = request.GET.get('vfolder', '')
if vfolder_pk:
from virtualfolder.models import VirtualFolder
try:
# If we are translating a virtual folder, then display its
# priority.
# Note that the passed virtual folder pk might be invalid.
priority = VirtualFolder.objects.get(pk=vfolder_pk).priority
except VirtualFolder.DoesNotExist:
pass
if priority is None:
# Retrieve the unit top priority, if any. This can happen if we are
# not in a virtual folder or if the passed virtual folder pk is
# invalid.
priority = unit.vfolders.aggregate(
priority=Max('priority'))['priority']
template_vars = {
'unit': unit,
'form': form,
'comment_form': comment_form,
'priority': priority,
'store': store,
'directory': directory,
'profile': user,
'user': request.user,
'project': project,
'language': language,
'source_language': translation_project.project.source_language,
'cantranslate': check_user_permission(user, "translate", directory),
'cansuggest': check_user_permission(user, "suggest", directory),
'canreview': check_user_permission(user, "review", directory),
'is_admin': check_user_permission(user, 'administrate', directory),
'altsrcs': find_altsrcs(unit,
alt_src_langs,
store=store,
project=project),
}
if translation_project.project.is_terminology or store.is_terminology:
t = loader.get_template('editor/units/term_edit.html')
else:
t = loader.get_template('editor/units/edit.html')
c = RequestContext(request, template_vars)
json['editor'] = t.render(c)
json['tm_suggestions'] = unit.get_tm_suggestions()
json['is_obsolete'] = unit.isobsolete()
# Return context rows if filtering is applied but
# don't return any if the user has asked not to have it
current_filter = request.GET.get('filter', 'all')
show_ctx = request.COOKIES.get('ctxShow', 'true')
if ((_is_filtered(request) or current_filter not in ('all', ))
and show_ctx == 'true'):
# TODO: review if this first 'if' branch makes sense
if translation_project.project.is_terminology or store.is_terminology:
json['ctx'] = _filter_ctx_units(store.units, unit, 0)
else:
ctx_qty = int(request.COOKIES.get('ctxQty', 1))
json['ctx'] = _filter_ctx_units(store.units, unit, ctx_qty)
return JsonResponse(json)
def get_edit_unit(request, unit):
"""Given a store path ``pootle_path`` and unit id ``uid``, gathers all the
necessary information to build the editing widget.
:return: A templatised editing widget is returned within the ``editor``
variable and paging information is also returned if the page
number has changed.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(instance=unit, request=request)
comment_form_class = unit_comment_form_factory(language)
comment_form = comment_form_class({}, instance=unit, request=request)
store = unit.store
directory = store.parent
user = request.profile
project = translation_project.project
alt_src_langs = get_alt_src_langs(request, user, translation_project)
altsrcs = find_altsrcs(unit, alt_src_langs, store=store, project=project)
source_language = translation_project.project.source_language
sources = {
unit.store.translation_project.language.code: unit.target_f.strings
for unit in altsrcs
}
sources[source_language.code] = unit.source_f.strings
priority = None
if 'virtualfolder' in settings.INSTALLED_APPS:
vfolder_pk = request.GET.get('vfolder', '')
if vfolder_pk:
from virtualfolder.models import VirtualFolder
try:
# If we are translating a virtual folder, then display its
# priority.
# Note that the passed virtual folder pk might be invalid.
priority = VirtualFolder.objects.get(pk=vfolder_pk).priority
except VirtualFolder.DoesNotExist:
pass
if priority is None:
# Retrieve the unit top priority, if any. This can happen if we are
# not in a virtual folder or if the passed virtual folder pk is
# invalid.
priority = unit.vfolders.aggregate(
priority=Max('priority')
)['priority']
template_vars = {
'unit': unit,
'form': form,
'comment_form': comment_form,
'priority': priority,
'store': store,
'directory': directory,
'profile': user,
'user': request.user,
'project': project,
'language': language,
'source_language': source_language,
'cantranslate': check_user_permission(user, "translate", directory),
'cansuggest': check_user_permission(user, "suggest", directory),
'canreview': check_user_permission(user, "review", directory),
'is_admin': check_user_permission(user, 'administrate', directory),
'altsrcs': altsrcs,
}
if translation_project.project.is_terminology or store.is_terminology:
t = loader.get_template('editor/units/term_edit.html')
else:
t = loader.get_template('editor/units/edit.html')
c = RequestContext(request, template_vars)
json.update({
'editor': t.render(c),
'tm_suggestions': unit.get_tm_suggestions(),
'is_obsolete': unit.isobsolete(),
'sources': sources,
})
return JsonResponse(json)
def create_notice(creator, message, directory):
if not check_user_permission(creator, "administrate", directory):
raise PermissionDenied
new_notice = Notice(directory=directory, message=message)
new_notice.save()
return new_notice
def create_notice(creator, message, directory):
if not check_user_permission(creator, "administrate", directory):
raise PermissionDenied
new_notice = Notice(directory=directory, message=message)
new_notice.save()
return new_notice
def get_edit_unit(request, unit):
"""Given a store path ``pootle_path`` and unit id ``uid``, gathers all the
necessary information to build the editing widget.
:return: A templatised editing widget is returned within the ``editor``
variable and paging information is also returned if the page
number has changed.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
form_class = unit_form_factory(language, snplurals, request)
form = form_class(instance=unit, request=request)
comment_form_class = unit_comment_form_factory(language)
comment_form = comment_form_class({}, instance=unit)
store = unit.store
directory = store.parent
user = request.user
alt_src_langs = get_alt_src_langs(request, user, translation_project)
project = translation_project.project
suggestions = get_sugg_list(unit)
template_vars = {
'unit': unit,
'form': form,
'comment_form': comment_form,
'store': store,
'directory': directory,
'project': project,
'language': language,
'source_language': translation_project.project.source_language,
'cantranslate': check_user_permission(user, "translate", directory),
'cansuggest': check_user_permission(user, "suggest", directory),
'canreview': check_user_permission(user, "review", directory),
'is_admin': check_user_permission(user, "administrate", directory),
'altsrcs': find_altsrcs(unit, alt_src_langs, store=store,
project=project),
'suggestions': suggestions,
}
if translation_project.project.is_terminology or store.is_terminology:
t = loader.get_template('editor/units/term_edit.html')
else:
t = loader.get_template('editor/units/edit.html')
c = RequestContext(request, template_vars)
json['editor'] = t.render(c)
rcode = 200
# Return context rows if filtering is applied but
# don't return any if the user has asked not to have it.
current_filter = request.GET.get('filter', 'all')
show_ctx = request.COOKIES.get('ctxShow', 'true')
if ((_is_filtered(request) or current_filter not in ('all',)) and
show_ctx == 'true'):
# TODO: review if this first 'if' branch makes sense.
if translation_project.project.is_terminology or store.is_terminology:
json['ctx'] = _filter_ctx_units(store.units, unit, 0)
else:
ctx_qty = int(request.COOKIES.get('ctxQty', 1))
json['ctx'] = _filter_ctx_units(store.units, unit, ctx_qty)
response = jsonify(json)
return HttpResponse(response, status=rcode, mimetype="application/json")
def test_get_edit_unit(project0_nongnu, get_edit_unit, client,
request_users, settings):
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
unit = get_edit_unit
store = unit.store
filetype = unit.store.filetype.name
directory = store.parent
translation_project = store.translation_project
project = translation_project.project
language = translation_project.language
response = client.get(
"/xhr/units/%s/edit/" % unit.id,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
request = response.wsgi_request
result = json.loads(response.content)
special_characters = []
for specialchar in language.specialchars:
code = ord(specialchar)
special_characters.append({
'display': CHARACTERS_NAMES.get(code, specialchar),
'code': code,
'hex_code': "U+" + hex(code)[2:].upper(),
'name': unicodedata.name(specialchar, ''),
})
src_lang = unit.store.translation_project.project.source_language
alt_src_langs = get_alt_src_langs(request, user, translation_project)
altsrcs = find_altsrcs(unit, alt_src_langs, store=store, project=project)
altsrcs = {x.id: x.data for x in altsrcs}
sources = {altsrcs[x]['language_code']: altsrcs[x]['target'] for x in altsrcs}
sources[src_lang.code] = unit.source
suggestions_dict = {x.id: dict(id=x.id, target=x.target.strings)
for x in unit.get_suggestions()}
assert result["is_obsolete"] is False
assert result["sources"] == sources
assert response.context["unit"] == unit
assert response.context["priority"] == store.priority
assert response.context["store"] == store
assert response.context["filetype"] == filetype
assert response.context["directory"] == directory
assert response.context["project"] == project
assert response.context["language"] == language
assert response.context["special_characters"] == special_characters
assert response.context["source_language"] == src_lang
assert response.context["altsrcs"] == altsrcs
assert response.context["suggestions_dict"] == suggestions_dict
assert response.context["cantranslate"] == check_user_permission(
user, "translate", directory)
assert response.context["cansuggest"] == check_user_permission(
user, "suggest", directory)
assert response.context["canreview"] == check_user_permission(
user, "review", directory)
assert response.context["has_admin_access"] == check_user_permission(
user, "administrate", directory)
def submit(request, unit):
"""Processes translation submissions and stores them in the database.
:return: An object in JSON notation that contains the previous and last
units for the unit next to unit ``uid``.
"""
json = {}
translation_project = request.translation_project
language = translation_project.language
user = request.user
if unit.hasplural():
snplurals = len(unit.source.strings)
else:
snplurals = None
# Store current time so that it is the same for all submissions
current_time = timezone.now()
# Update current unit instance's attributes
unit.submitted_by = request.user
unit.submitted_on = current_time
form_class = unit_form_factory(language, snplurals, request)
form = form_class(request.POST, instance=unit, request=request)
if form.is_valid():
if form.updated_fields:
for field, old_value, new_value in form.updated_fields:
sub = Submission(
creation_time=current_time,
translation_project=translation_project,
submitter=request.user,
unit=unit,
field=field,
type=SubmissionTypes.NORMAL,
old_value=old_value,
new_value=new_value,
)
sub.save()
form.instance._log_user = request.user
form.save()
translation_submitted.send(
sender=translation_project,
unit=form.instance,
user=request.user,
)
has_critical_checks = unit.qualitycheck_set.filter(
category=Category.CRITICAL
).exists()
if has_critical_checks:
can_review = check_user_permission(user, "review", unit.store.parent)
ctx = {
'canreview': can_review,
'unit': unit
}
template = loader.get_template('editor/units/xhr_checks.html')
context = RequestContext(request, ctx)
json['checks'] = template.render(context)
rcode = 200
else:
# Form failed
#FIXME: we should display validation errors here
rcode = 400
json["msg"] = _("Failed to process submission.")
response = jsonify(json)
return HttpResponse(response, status=rcode, mimetype="application/json")
