def update_translation(request):
"""Update entity translation for the specified locale and user."""
try:
entity = request.POST['entity']
string = request.POST['translation']
locale = request.POST['locale']
plural_form = request.POST['plural_form']
original = request.POST['original']
ignore_check = request.POST['ignore_check']
except MultiValueDictKeyError as error:
log.error(str(error))
return HttpResponse("error")
try:
e = Entity.objects.get(pk=entity)
except Entity.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
try:
l = Locale.objects.get(code__iexact=locale)
except Locale.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
if plural_form == "-1":
plural_form = None
user = request.user
if not request.user.is_authenticated():
if e.resource.project.pk != 1:
log.error("Not authenticated")
return HttpResponse("error")
else:
user = None
try:
quality_checks = UserProfile.objects.get(user=user).quality_checks
except UserProfile.DoesNotExist as error:
quality_checks = True
ignore = False
if ignore_check == 'true' or not quality_checks:
ignore = True
now = timezone.now()
can_translate = (
request.user.has_perm('base.can_translate_locale', l)
and not request.user.profile.force_suggestions
)
translations = Translation.objects.filter(
entity=e, locale=l, plural_form=plural_form)
# Newlines are not allowed in .lang files (bug 1190754)
if e.resource.format == 'lang' and '\n' in string:
return HttpResponse('Newline characters are not allowed.')
# Translations exist
if len(translations) > 0:
# Same translation exists
try:
t = translations.get(string=string)
# If added by privileged user, approve and unfuzzy it
if can_translate:
# Unless there's nothing to be changed
if t.user is not None and t.approved and t.approved_user \
and t.approved_date and not t.fuzzy:
return HttpResponse("Same translation already exists.")
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
unapprove(translations)
unfuzzy(translations)
if t.user is None:
t.user = user
t.approved = True
t.approved_date = timezone.now()
t.fuzzy = False
if t.approved_user is None:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return HttpResponse(json.dumps({
'type': 'updated',
'translation': t.serialize(),
}), content_type='application/json')
# If added by non-privileged user, unfuzzy it
else:
if t.fuzzy:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if t.user is None:
t.user = user
t.approved = False
t.approved_user = None
t.approved_date = None
t.fuzzy = False
if request.user.is_authenticated():
t.save()
return HttpResponse(json.dumps({
'type': 'updated',
'translation': t.serialize(),
}), content_type='application/json')
return HttpResponse("Same translation already exists.")
# Different translation added
except:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if can_translate:
unapprove(translations)
unfuzzy(translations)
t = Translation(
entity=e, locale=l, user=user, string=string,
plural_form=plural_form, date=now,
approved=can_translate)
if can_translate:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
active = get_translation(
entity=e, locale=l, plural_form=plural_form)
return HttpResponse(json.dumps({
'type': 'added',
'translation': active.serialize(),
}), content_type='application/json')
# No translations saved yet
else:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
t = Translation(
entity=e, locale=l, user=user, string=string,
plural_form=plural_form, date=now,
approved=can_translate)
if can_translate:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return HttpResponse(json.dumps({
'type': 'saved',
'translation': t.serialize(),
}), content_type='application/json')
def update_translation(request):
"""Update entity translation for the specified locale and user."""
try:
entity = request.POST['entity']
string = request.POST['translation']
locale = request.POST['locale']
plural_form = request.POST['plural_form']
original = request.POST['original']
ignore_check = request.POST['ignore_check']
approve = json.loads(request.POST['approve'])
paths = request.POST.getlist('paths[]')
except MultiValueDictKeyError as e:
return HttpResponseBadRequest('Bad Request: {error}'.format(error=e))
try:
e = Entity.objects.get(pk=entity)
except Entity.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
try:
l = Locale.objects.get(code__iexact=locale)
except Locale.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
if plural_form == "-1":
plural_form = None
user = request.user
project = e.resource.project
if not request.user.is_authenticated():
if project.pk != 1:
log.error("Not authenticated")
return HttpResponse("error")
else:
user = None
try:
quality_checks = UserProfile.objects.get(user=user).quality_checks
except UserProfile.DoesNotExist as error:
quality_checks = True
ignore = False
if ignore_check == 'true' or not quality_checks:
ignore = True
now = timezone.now()
can_translate = (
request.user.has_perm('base.can_translate_locale', l)
and (not request.user.profile.force_suggestions or approve)
)
translations = Translation.objects.filter(
entity=e, locale=l, plural_form=plural_form)
# Newlines are not allowed in .lang files (bug 1190754)
if e.resource.format == 'lang' and '\n' in string:
return HttpResponse('Newline characters are not allowed.')
# Translations exist
if len(translations) > 0:
# Same translation exists
try:
t = translations.get(string=string)
# If added by privileged user, approve and unfuzzy it
if can_translate:
# Unless there's nothing to be changed
if t.user is not None and t.approved and t.approved_user \
and t.approved_date and not t.fuzzy:
return JsonResponse({
'same': True,
'message': 'Same translation already exists.',
})
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
translations.update(approved=False, approved_user=None, approved_date=None)
translations.update(fuzzy=False)
if t.user is None:
t.user = user
t.approved = True
t.approved_date = timezone.now()
t.fuzzy = False
if t.approved_user is None:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return JsonResponse({
'type': 'updated',
'translation': t.serialize(),
'stats': TranslatedResource.objects.stats(project, paths, l),
'authors': Translation.authors(l, project, paths).serialize(),
})
# If added by non-privileged user, unfuzzy it
else:
if t.fuzzy:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if t.user is None:
t.user = user
t.approved = False
t.approved_user = None
t.approved_date = None
t.fuzzy = False
if request.user.is_authenticated():
t.save()
return JsonResponse({
'type': 'updated',
'translation': t.serialize(),
'stats': TranslatedResource.objects.stats(project, paths, l),
'authors': Translation.authors(l, project, paths).serialize(),
})
return JsonResponse({
'same': True,
'message': 'Same translation already exists.',
})
# Different translation added
except:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if can_translate:
translations.update(approved=False, approved_user=None, approved_date=None)
translations.update(fuzzy=False)
t = Translation(
entity=e, locale=l, user=user, string=string,
plural_form=plural_form, date=now,
approved=can_translate)
if can_translate:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
# Return active (approved or latest) translation
try:
active = translations.filter(approved=True).latest("date")
except Translation.DoesNotExist:
active = translations.latest("date")
return JsonResponse({
'type': 'added',
'translation': active.serialize(),
'stats': TranslatedResource.objects.stats(project, paths, l),
'authors': Translation.authors(l, project, paths).serialize(),
})
# No translations saved yet
else:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
t = Translation(
entity=e, locale=l, user=user, string=string,
plural_form=plural_form, date=now,
approved=can_translate)
if can_translate:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return JsonResponse({
'type': 'saved',
'translation': t.serialize(),
'stats': TranslatedResource.objects.stats(project, paths, l),
'authors': Translation.authors(l, project, paths).serialize(),
})
def update_translation(request, template=None):
"""Update entity translation for the specified locale and user."""
log.debug("Update entity translation for the specified locale and user.")
if not request.is_ajax():
log.error("Non-AJAX request")
raise Http404
if request.method != 'POST':
log.error("Non-POST request")
raise Http404
try:
entity = request.POST['entity']
string = request.POST['translation']
locale = request.POST['locale']
plural_form = request.POST['plural_form']
original = request.POST['original']
ignore_check = request.POST['ignore_check']
except MultiValueDictKeyError as error:
log.error(str(error))
return HttpResponse("error")
log.debug("Entity: " + entity)
log.debug("Translation: " + string)
log.debug("Locale: " + locale)
try:
e = Entity.objects.get(pk=entity)
except Entity.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
try:
l = Locale.objects.get(code=locale)
except Locale.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
if plural_form == "-1":
plural_form = None
user = request.user
if not request.user.is_authenticated():
if e.resource.project.pk != 1:
log.error("Not authenticated")
return HttpResponse("error")
else:
user = None
try:
quality_checks = UserProfile.objects.get(user=user).quality_checks
except UserProfile.DoesNotExist as error:
quality_checks = True
ignore = False
if ignore_check == 'true' or not quality_checks:
ignore = True
now = datetime.datetime.now()
can_localize = request.user.has_perm('base.can_localize')
translations = Translation.objects.filter(
entity=e, locale=l, plural_form=plural_form)
# Translations exist
if len(translations) > 0:
# Same translation exists
try:
t = translations.get(string__iexact=string)
# If added by privileged user, approve and unfuzzy it
if can_localize:
# Unless there's nothing to be changed
if t.user is not None and t.approved and t.approved_user \
and t.approved_date and not t.fuzzy:
return HttpResponse("Same translation already exist.")
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
unapprove(translations)
unfuzzy(translations)
if t.user is None:
t.user = user
t.approved = True
t.fuzzy = False
if t.approved_user is None:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return HttpResponse(json.dumps({
'type': 'updated',
'translation': t.serialize(),
}), mimetype='application/json')
# If added by non-privileged user, unfuzzy it
else:
if t.fuzzy:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if t.user is None:
t.user = user
t.approved = False
t.approved_user = None
t.approved_date = None
t.fuzzy = False
if request.user.is_authenticated():
t.save()
return HttpResponse(json.dumps({
'type': 'updated',
'translation': t.serialize(),
}), mimetype='application/json')
return HttpResponse("Same translation already exist.")
# Different translation added
except:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if can_localize:
unapprove(translations)
unfuzzy(translations)
t = Translation(
entity=e, locale=l, user=user, string=string,
plural_form=plural_form, date=now,
approved=can_localize)
if can_localize:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
active = get_translation(
entity=e, locale=l, plural_form=plural_form)
return HttpResponse(json.dumps({
'type': 'added',
'translation': active.serialize(),
}), mimetype='application/json')
# No translations saved yet
else:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
t = Translation(
entity=e, locale=l, user=user, string=string,
plural_form=plural_form, date=now,
approved=can_localize)
if can_localize:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return HttpResponse(json.dumps({
'type': 'saved',
'translation': t.serialize(),
}), mimetype='application/json')
def update_translation(request, template=None):
"""Update entity translation for the specified locale and user."""
log.debug("Update entity translation for the specified locale and user.")
if not request.is_ajax():
log.error("Non-AJAX request")
raise Http404
if request.method != "POST":
log.error("Non-POST request")
raise Http404
try:
entity = request.POST["entity"]
string = request.POST["translation"]
locale = request.POST["locale"]
plural_form = request.POST["plural_form"]
original = request.POST["original"]
ignore_check = request.POST["ignore_check"]
except MultiValueDictKeyError as error:
log.error(str(error))
return HttpResponse("error")
log.debug("Entity: " + entity)
log.debug("Translation: " + string)
log.debug("Locale: " + locale)
try:
e = Entity.objects.get(pk=entity)
except Entity.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
try:
l = Locale.objects.get(code__iexact=locale)
except Locale.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
if plural_form == "-1":
plural_form = None
user = request.user
if not request.user.is_authenticated():
if e.resource.project.pk != 1:
log.error("Not authenticated")
return HttpResponse("error")
else:
user = None
try:
quality_checks = UserProfile.objects.get(user=user).quality_checks
except UserProfile.DoesNotExist as error:
quality_checks = True
ignore = False
if ignore_check == "true" or not quality_checks:
ignore = True
now = timezone.now()
can_localize = request.user.has_perm("base.can_localize")
translations = Translation.objects.filter(entity=e, locale=l, plural_form=plural_form)
# Newlines are not allowed in .lang files (bug 1190754)
if e.resource.format == "lang" and "\n" in string:
return HttpResponse("Newline characters are not allowed.")
# Translations exist
if len(translations) > 0:
# Same translation exists
try:
t = translations.get(string=string)
# If added by privileged user, approve and unfuzzy it
if can_localize:
# Unless there's nothing to be changed
if t.user is not None and t.approved and t.approved_user and t.approved_date and not t.fuzzy:
return HttpResponse("Same translation already exists.")
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
unapprove(translations)
unfuzzy(translations)
if t.user is None:
t.user = user
t.approved = True
t.approved_date = timezone.now()
t.fuzzy = False
if t.approved_user is None:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return HttpResponse(
json.dumps({"type": "updated", "translation": t.serialize()}), content_type="application/json"
)
# If added by non-privileged user, unfuzzy it
else:
if t.fuzzy:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if t.user is None:
t.user = user
t.approved = False
t.approved_user = None
t.approved_date = None
t.fuzzy = False
if request.user.is_authenticated():
t.save()
return HttpResponse(
json.dumps({"type": "updated", "translation": t.serialize()}), content_type="application/json"
)
return HttpResponse("Same translation already exists.")
# Different translation added
except:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if can_localize:
unapprove(translations)
unfuzzy(translations)
t = Translation(
entity=e, locale=l, user=user, string=string, plural_form=plural_form, date=now, approved=can_localize
)
if can_localize:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
active = get_translation(entity=e, locale=l, plural_form=plural_form)
return HttpResponse(
json.dumps({"type": "added", "translation": active.serialize()}), content_type="application/json"
)
# No translations saved yet
else:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
t = Translation(
entity=e, locale=l, user=user, string=string, plural_form=plural_form, date=now, approved=can_localize
)
if can_localize:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return HttpResponse(
json.dumps({"type": "saved", "translation": t.serialize()}), content_type="application/json"
)
def update_translation(request, template=None):
"""Update entity translation for the specified locale and user."""
log.debug("Update entity translation for the specified locale and user.")
if not request.is_ajax():
log.error("Non-AJAX request")
raise Http404
if request.method != 'POST':
log.error("Non-POST request")
raise Http404
try:
entity = request.POST['entity']
string = request.POST['translation']
locale = request.POST['locale']
plural_form = request.POST['plural_form']
original = request.POST['original']
ignore_check = request.POST['ignore_check']
except MultiValueDictKeyError as error:
log.error(str(error))
return HttpResponse("error")
log.debug("Entity: " + entity)
log.debug("Translation: " + string)
log.debug("Locale: " + locale)
try:
e = Entity.objects.get(pk=entity)
except Entity.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
try:
l = Locale.objects.get(code__iexact=locale)
except Locale.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
if plural_form == "-1":
plural_form = None
user = request.user
if not request.user.is_authenticated():
if e.resource.project.pk != 1:
log.error("Not authenticated")
return HttpResponse("error")
else:
user = None
try:
quality_checks = UserProfile.objects.get(user=user).quality_checks
except UserProfile.DoesNotExist as error:
quality_checks = True
ignore = False
if ignore_check == 'true' or not quality_checks:
ignore = True
now = timezone.now()
can_localize = request.user.has_perm('base.can_localize')
translations = Translation.objects.filter(entity=e,
locale=l,
plural_form=plural_form)
# Newlines are not allowed in .lang files (bug 1190754)
if e.resource.format == 'lang' and '\n' in string:
return HttpResponse('Newline characters are not allowed.')
# Translations exist
if len(translations) > 0:
# Same translation exists
try:
t = translations.get(string=string)
# If added by privileged user, approve and unfuzzy it
if can_localize:
# Unless there's nothing to be changed
if t.user is not None and t.approved and t.approved_user \
and t.approved_date and not t.fuzzy:
return HttpResponse("Same translation already exists.")
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
unapprove(translations)
unfuzzy(translations)
if t.user is None:
t.user = user
t.approved = True
t.approved_date = timezone.now()
t.fuzzy = False
if t.approved_user is None:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return HttpResponse(json.dumps({
'type': 'updated',
'translation': t.serialize(),
}),
content_type='application/json')
# If added by non-privileged user, unfuzzy it
else:
if t.fuzzy:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if t.user is None:
t.user = user
t.approved = False
t.approved_user = None
t.approved_date = None
t.fuzzy = False
if request.user.is_authenticated():
t.save()
return HttpResponse(json.dumps({
'type':
'updated',
'translation':
t.serialize(),
}),
content_type='application/json')
return HttpResponse("Same translation already exists.")
# Different translation added
except:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if can_localize:
unapprove(translations)
unfuzzy(translations)
t = Translation(entity=e,
locale=l,
user=user,
string=string,
plural_form=plural_form,
date=now,
approved=can_localize)
if can_localize:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
active = get_translation(entity=e,
locale=l,
plural_form=plural_form)
return HttpResponse(json.dumps({
'type': 'added',
'translation': active.serialize(),
}),
content_type='application/json')
# No translations saved yet
else:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
t = Translation(entity=e,
locale=l,
user=user,
string=string,
plural_form=plural_form,
date=now,
approved=can_localize)
if can_localize:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return HttpResponse(json.dumps({
'type': 'saved',
'translation': t.serialize(),
}),
content_type='application/json')
def update_translation(request):
"""Update entity translation for the specified locale and user."""
try:
entity = request.POST['entity']
string = request.POST['translation']
locale = request.POST['locale']
plural_form = request.POST['plural_form']
original = request.POST['original']
ignore_check = request.POST['ignore_check']
approve = request.POST.get('approve', 'false') == 'true'
force_suggestions = request.POST.get('force_suggestions', 'false') == 'true'
paths = request.POST.getlist('paths[]')
except MultiValueDictKeyError as e:
return HttpResponseBadRequest('Bad Request: {error}'.format(error=e))
try:
e = Entity.objects.get(pk=entity)
except Entity.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
try:
l = Locale.objects.get(code=locale)
except Locale.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
if plural_form == "-1":
plural_form = None
user = request.user
project = e.resource.project
try:
quality_checks = UserProfile.objects.get(user=user).quality_checks
except UserProfile.DoesNotExist as error:
quality_checks = True
ignore = False
if ignore_check == 'true' or not quality_checks:
ignore = True
now = timezone.now()
can_translate = (
request.user.can_translate(project=project, locale=l) and
(not force_suggestions or approve)
)
translations = Translation.objects.filter(
entity=e, locale=l, plural_form=plural_form)
# Newlines are not allowed in .lang files (bug 1190754)
if e.resource.format == 'lang' and '\n' in string:
return HttpResponse('Newline characters are not allowed.')
# Translations exist
if len(translations) > 0:
# Same translation exists
same_translations = translations.filter(string=string).order_by('-approved', '-date')
if len(same_translations) > 0:
t = same_translations[0]
# If added by privileged user, approve and unfuzzy it
if can_translate:
# Unless there's nothing to be changed
if t.user is not None and t.approved and t.approved_user \
and t.approved_date and not t.fuzzy:
return JsonResponse({
'same': True,
'message': 'Same translation already exists.',
})
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
translations.update(approved=False, approved_user=None, approved_date=None)
translations.update(fuzzy=False)
if t.user is None:
t.user = user
t.approved = True
t.approved_date = timezone.now()
t.fuzzy = False
if t.approved_user is None:
t.approved_user = user
t.approved_date = now
t.save()
return JsonResponse({
'type': 'updated',
'translation': t.serialize(),
'stats': TranslatedResource.objects.stats(project, paths, l),
})
# If added by non-privileged user, unfuzzy it
else:
if t.fuzzy:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if t.user is None:
t.user = user
t.approved = False
t.approved_user = None
t.approved_date = None
t.fuzzy = False
t.save()
return JsonResponse({
'type': 'updated',
'translation': t.serialize(),
'stats': TranslatedResource.objects.stats(project, paths, l),
})
return JsonResponse({
'same': True,
'message': 'Same translation already exists.',
})
# Different translation added
else:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if can_translate:
translations.update(approved=False, approved_user=None, approved_date=None)
translations.update(fuzzy=False)
t = Translation(
entity=e, locale=l, user=user, string=string,
plural_form=plural_form, date=now,
approved=can_translate)
if can_translate:
t.approved_user = user
t.approved_date = now
t.save()
# Return active (approved or latest) translation
try:
active = translations.filter(approved=True).latest("date")
except Translation.DoesNotExist:
active = translations.latest("date")
return JsonResponse({
'type': 'added',
'translation': active.serialize(),
'stats': TranslatedResource.objects.stats(project, paths, l),
})
# No translations saved yet
else:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
t = Translation(
entity=e, locale=l, user=user, string=string,
plural_form=plural_form, date=now,
approved=can_translate)
if can_translate:
t.approved_user = user
t.approved_date = now
t.save()
return JsonResponse({
'type': 'saved',
'translation': t.serialize(),
'stats': TranslatedResource.objects.stats(project, paths, l),
})
def update_translation(request):
"""Update entity translation for the specified locale and user."""
try:
entity = request.POST["entity"]
string = request.POST["translation"]
locale = request.POST["locale"]
plural_form = request.POST["plural_form"]
original = request.POST["original"]
ignore_check = request.POST["ignore_check"]
approve = json.loads(request.POST["approve"])
paths = request.POST.getlist("paths[]")
except MultiValueDictKeyError as e:
return HttpResponseBadRequest("Bad Request: {error}".format(error=e))
try:
e = Entity.objects.get(pk=entity)
except Entity.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
try:
l = Locale.objects.get(code__iexact=locale)
except Locale.DoesNotExist as error:
log.error(str(error))
return HttpResponse("error")
if plural_form == "-1":
plural_form = None
user = request.user
if not request.user.is_authenticated():
if e.resource.project.pk != 1:
log.error("Not authenticated")
return HttpResponse("error")
else:
user = None
try:
quality_checks = UserProfile.objects.get(user=user).quality_checks
except UserProfile.DoesNotExist as error:
quality_checks = True
ignore = False
if ignore_check == "true" or not quality_checks:
ignore = True
now = timezone.now()
can_translate = request.user.has_perm("base.can_translate_locale", l) and (
not request.user.profile.force_suggestions or approve
)
translations = Translation.objects.filter(entity=e, locale=l, plural_form=plural_form)
# Newlines are not allowed in .lang files (bug 1190754)
if e.resource.format == "lang" and "\n" in string:
return HttpResponse("Newline characters are not allowed.")
# Translations exist
if len(translations) > 0:
# Same translation exists
try:
t = translations.get(string=string)
# If added by privileged user, approve and unfuzzy it
if can_translate:
# Unless there's nothing to be changed
if t.user is not None and t.approved and t.approved_user and t.approved_date and not t.fuzzy:
return HttpResponse("Same translation already exists.")
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
translations.update(approved=False, approved_user=None, approved_date=None)
translations.update(fuzzy=False)
if t.user is None:
t.user = user
t.approved = True
t.approved_date = timezone.now()
t.fuzzy = False
if t.approved_user is None:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return JsonResponse(
{
"type": "updated",
"translation": t.serialize(),
"stats": TranslatedResource.objects.stats(e.resource.project, paths, l),
}
)
# If added by non-privileged user, unfuzzy it
else:
if t.fuzzy:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if t.user is None:
t.user = user
t.approved = False
t.approved_user = None
t.approved_date = None
t.fuzzy = False
if request.user.is_authenticated():
t.save()
return JsonResponse(
{
"type": "updated",
"translation": t.serialize(),
"stats": TranslatedResource.objects.stats(e.resource.project, paths, l),
}
)
return HttpResponse("Same translation already exists.")
# Different translation added
except:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
if can_translate:
translations.update(approved=False, approved_user=None, approved_date=None)
translations.update(fuzzy=False)
t = Translation(
entity=e, locale=l, user=user, string=string, plural_form=plural_form, date=now, approved=can_translate
)
if can_translate:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
# Return active (approved or latest) translation
try:
active = translations.filter(approved=True).latest("date")
except Translation.DoesNotExist:
active = translations.latest("date")
return JsonResponse(
{
"type": "added",
"translation": active.serialize(),
"stats": TranslatedResource.objects.stats(e.resource.project, paths, l),
}
)
# No translations saved yet
else:
warnings = utils.quality_check(original, string, l, ignore)
if warnings:
return warnings
t = Translation(
entity=e, locale=l, user=user, string=string, plural_form=plural_form, date=now, approved=can_translate
)
if can_translate:
t.approved_user = user
t.approved_date = now
if request.user.is_authenticated():
t.save()
return JsonResponse(
{
"type": "saved",
"translation": t.serialize(),
"stats": TranslatedResource.objects.stats(e.resource.project, paths, l),
}
)
