def resource_translations_delete(request, project_slug, resource_slug, lang_code):
"""
Delete the set of Translation objects for a specific Language in a Resource.
"""
resource = get_object_or_404(Resource, project__slug = project_slug,
slug = resource_slug)
language = get_object_or_404(Language, code=lang_code)
# Use a flag to denote if there is an attempt to delete the source language.
is_source_language = False
if resource.source_language == language:
is_source_language = True
if request.method == 'POST':
Translation.objects.filter(resource=resource,
language=language).delete()
messages.success(request,
_("Deleted %(lang)s translation for resource "
"%(resource)s.") % {
'lang': language.name,
'resource': resource.name})
invalidate_stats_cache(resource, language, user=request.user)
return HttpResponseRedirect(reverse('resource_detail',
args=[resource.project.slug, resource.slug]),)
else:
return render_to_response(
'resources/resource_translations_confirm_delete.html',
{'resource': resource,
'language': language,
'is_source_language': is_source_language},
context_instance=RequestContext(request))
def delete(self, *args, **kwargs):
"""
Do some extra processing along with the actual delete to db.
"""
# Import is here to avoid circular imports
from transifex.resources.handlers import invalidate_stats_cache
invalidate_stats_cache(self, self.source_language)
RLStats.objects.filter(resource=self).delete()
super(Resource, self).delete(*args, **kwargs)
def delete(self, *args, **kwargs):
"""
Do some extra processing along with the actual delete to db.
"""
# Import is here to avoid circular imports
from transifex.resources.handlers import invalidate_stats_cache
invalidate_stats_cache(self, self.source_language)
RLStats.objects.filter(resource=self).delete()
super(Resource, self).delete(*args, **kwargs)
def delete(self):
"""
Delete a specific translation.
Delete all Translation objects that belong to the specified resource
and are in the specified language.
"""
TranslationModel.objects.filter(resource=self.resource,
language=self.language).delete()
invalidate_stats_cache(self.resource,
self.language,
user=self.request.user)
def proofread(request, project_slug, lang_code, resource_slug=None, *args, **kwargs):
"""AJAX view that sets the reviewed flag on Translations to true or false.
The request data is expected in JSON, with the following format:
{
'true': [1,2,3]
'false': [4,5]
}
Note: The IDs are source entity IDs.
"""
if request.method != 'POST':
return HttpResponse(status=405)
project = get_object_or_404(Project, slug=project_slug)
resource = get_object_or_404(Resource, slug=resource_slug, project=project)
try:
language = Language.objects.by_code_or_alias(lang_code)
except Language.DoesNotExist:
raise Http404
# Check if the user has the necessary permissions to review strings.
check = ProjectPermission(request.user)
if not check.proofread(project, language):
return permission_denied(request)
request_data = simplejson.loads(request.raw_post_data)
if 'true' in request_data:
source_entity_ids = request_data['true']
translations = Translation.objects.filter(
source_entity__id__in=source_entity_ids,
language__code=lang_code,
)
translations.update(reviewed=True)
ReviewHistory.add_many(translations, request.user, project.id, reviewed=True)
if 'false' in request_data:
source_entity_ids = request_data['false']
translations = Translation.objects.filter(
source_entity__id__in=source_entity_ids,
language__code=lang_code,
)
translations.update(reviewed=False)
ReviewHistory.add_many(translations, request.user, project.id, reviewed=False)
invalidate_stats_cache(resource, language, user=request.user)
return HttpResponse(status=200)
def delete(self):
"""
Delete a specific translation.
Delete all Translation objects that belong to the specified resource
and are in the specified language.
"""
TranslationModel.objects.filter(
resource=self.resource,
language=self.language
).delete()
invalidate_stats_cache(
self.resource, self.language, user=self.request.user
)
def clone_language(request,
project_slug=None,
resource_slug=None,
source_lang_code=None,
target_lang_code=None):
'''
Get a resource, a src lang and a target lang and clone all translation
strings for the src to the target.
The user is redirected to the online editor for the target language.
'''
resource = get_object_or_404(Resource,
slug=resource_slug,
project__slug=project_slug)
# Permissions handling
# Project should always be available
project = get_object_or_404(Project, slug=project_slug)
team = Team.objects.get_or_none(project, target_lang_code)
check = ProjectPermission(request.user)
if not check.submit_translations(team or project) or not \
resource.accept_translations:
return permission_denied(request)
source_lang = get_object_or_404(Language, code=source_lang_code)
target_lang = get_object_or_404(Language, code=target_lang_code)
# get the strings which will be cloned
strings = Translation.objects.filter(resource=resource,
language=source_lang)
# If the language we want to create, has the same plural rules with the
# source, we also copy the pluralized translations!
if not source_lang.get_pluralrules() == target_lang.get_pluralrules():
strings = strings.exclude(source_entity__pluralized=True)
# clone them in new translation
for s in strings:
Translation.objects.get_or_create(language=target_lang,
string=s.string,
source_entity=s.source_entity,
rule=s.rule,
resource=s.resource)
invalidate_stats_cache(resource, target_lang, user=request.user)
return HttpResponseRedirect(
reverse('translate_resource',
args=[project_slug, resource_slug, target_lang_code]), )
def handle(self, **options):
from transifex.resources.models import Resource, SourceEntity, Translation
from transifex.resources.handlers import invalidate_stats_cache
en = Language.objects.get(code='en-US')
p = Project.objects.get(slug="bzmenu")
for r in Resource.objects.filter(project=p):
for orig in Translation.objects.filter(resource=r, language=en):
Translation.objects.exclude(language=en
).filter(resource=r, string=orig.string).delete()
# reset Stats
for r in Resource.objects.filter(project=p):
for l in Language.objects.filter(pk__in=Translation.objects.filter(resource=r
).order_by('language').values_list('language', flat=True).distinct()):
invalidate_stats_cache(r, l)
def clone_language(request, project_slug=None, resource_slug=None,
source_lang_code=None, target_lang_code=None):
'''
Get a resource, a src lang and a target lang and clone all translation
strings for the src to the target.
The user is redirected to the online editor for the target language.
'''
resource = get_object_or_404(Resource, slug=resource_slug,
project__slug=project_slug)
# Permissions handling
# Project should always be available
project = get_object_or_404(Project, slug=project_slug)
team = Team.objects.get_or_none(project, target_lang_code)
check = ProjectPermission(request.user)
if not check.submit_translations(team or project) or not \
resource.accept_translations:
return permission_denied(request)
source_lang = get_object_or_404(Language, code=source_lang_code)
target_lang = get_object_or_404(Language, code=target_lang_code)
# get the strings which will be cloned
strings = Translation.objects.filter(
resource = resource,
language = source_lang)
# If the language we want to create, has the same plural rules with the
# source, we also copy the pluralized translations!
if not source_lang.get_pluralrules() == target_lang.get_pluralrules():
strings = strings.exclude(source_entity__pluralized = True)
# clone them in new translation
for s in strings:
Translation.objects.get_or_create(
language=target_lang, string=s.string,
source_entity=s.source_entity, rule=s.rule,
resource=s.resource
)
invalidate_stats_cache(resource, target_lang, user=request.user)
return HttpResponseRedirect(reverse('translate_resource', args=[project_slug,
resource_slug, target_lang_code]),)
def delete_translation(request,
project_slug=None,
resource_slug=None,
lang_code=None):
"""
Delete a list of translations according to the post request.
"""
if not request.POST:
return HttpResponseBadRequest()
project = get_object_or_404(Project, slug=project_slug)
resource = get_object_or_404(Resource, slug=resource_slug, project=project)
language = get_object_or_404(Language, code=lang_code)
data = simplejson.loads(request.raw_post_data)
to_delete = data["to_delete"]
ids = []
# Ensure that there are no empty '' ids
for se_id in to_delete:
if se_id:
ids.append(se_id)
try:
translations = Translation.objects.filter(source_entity__pk__in=ids,
language=language)
translations.delete()
# request.user.message_set.create(
# message=_("Translations deleted successfully!"))
except:
# request.user.message_set.create(
# message=_("Failed to delete translations due to some error!"))
raise Http404
invalidate_stats_cache(resource, language, user=request.user)
return HttpResponse(status=200)
def resource_translations_delete(request, project_slug, resource_slug,
lang_code):
"""
Delete the set of Translation objects for a specific Language in a Resource.
"""
resource = get_object_or_404(Resource,
project__slug=project_slug,
slug=resource_slug)
language = get_object_or_404(Language, code=lang_code)
# Use a flag to denote if there is an attempt to delete the source language.
is_source_language = False
if resource.source_language == language:
is_source_language = True
if request.method == 'POST':
Translation.objects.filter(resource=resource,
language=language).delete()
messages.success(
request,
_("Deleted %(lang)s translation for resource "
"%(resource)s.") % {
'lang': language.name,
'resource': resource.name
})
invalidate_stats_cache(resource, language, user=request.user)
return HttpResponseRedirect(
reverse('resource_detail',
args=[resource.project.slug, resource.slug]), )
else:
return render_to_response(
'resources/resource_translations_confirm_delete.html', {
'resource': resource,
'language': language,
'is_source_language': is_source_language
},
context_instance=RequestContext(request))
def delete_translation(request, project_slug=None, resource_slug=None,
lang_code=None):
"""
Delete a list of translations according to the post request.
"""
if not request.POST:
return HttpResponseBadRequest()
project = get_object_or_404(Project, slug=project_slug)
resource = get_object_or_404(Resource, slug=resource_slug, project=project)
language = get_object_or_404(Language, code=lang_code)
data = simplejson.loads(request.raw_post_data)
to_delete = data["to_delete"]
ids = []
# Ensure that there are no empty '' ids
for se_id in to_delete:
if se_id:
ids.append(se_id)
try:
translations = Translation.objects.filter(source_entity__pk__in=ids,
language=language)
translations.delete()
# request.user.message_set.create(
# message=_("Translations deleted successfully!"))
except:
# request.user.message_set.create(
# message=_("Failed to delete translations due to some error!"))
raise Http404
invalidate_stats_cache(resource, language, user=request.user)
return HttpResponse(status=200)
if translation_string.reviewed:
if not review_perm:
raise LotteBadRequestError(
_('You are not allowed to edit a reviewed string.'))
# FIXME: Maybe we don't want to permit anyone to delete!!!
# If an empty string has been issued then we delete the translation.
if target_string == "":
translation_string.delete()
else:
translation_string.string = target_string
translation_string.user = user
translation_string.save()
_add_copyright(source_string, target_language, user)
invalidate_stats_cache(resource, target_language, user=user)
except Translation.DoesNotExist:
# Only create new if the translation string sent, is not empty!
if target_string != "":
Translation.objects.create(
source_entity=source_string.source_entity,
user=user,
language=target_language,
rule=rule,
string=target_string,
resource=resource)
_add_copyright(source_string, target_language, user)
invalidate_stats_cache(resource, target_language, user=user)
else:
# In cases of pluralized translations, sometimes only one
# translation will exist and the rest plural forms will be
translation_string = Translation.objects.get(
source_entity=source_string.source_entity,
language=target_language, rule=rule
)
# FIXME: Maybe we don't want to permit anyone to delete!!!
# If an empty string has been issued then we delete the translation.
if target_string == "":
translation_string.delete()
else:
translation_string.string = target_string
translation_string.user = user
translation_string.save()
_add_copyright(source_string, target_language, user)
invalidate_stats_cache(resource, target_language, user=user)
except Translation.DoesNotExist:
# Only create new if the translation string sent, is not empty!
if target_string != "":
Translation.objects.create(
source_entity=source_string.source_entity, user=user,
language=target_language, rule=rule, string=target_string,
resource=resource
)
_add_copyright(source_string, target_language, user)
invalidate_stats_cache(resource, target_language, user=user)
else:
# In cases of pluralized translations, sometimes only one
# translation will exist and the rest plural forms will be
# empty. If the user wants to delete all of them, we need
# to let by the ones that don't already have a translation.
)
except SourceEntity.DoesNotExist:
continue
tr, created = Suggestion.objects.get_or_create(
string = j.translation,
source_entity = se,
language = self.language
)
self._post_save2db(strings_added, strings_updated, strings_deleted,
is_source, user, overwrite_translations)
if strings_added + strings_updated + strings_deleted > 0:
# Invalidate cache after saving file
invalidate_stats_cache(self.resource, self.language, user=user)
if self.language == self.resource.source_language:
nt = 'project_resource_changed'
else:
nt = 'project_resource_translated'
context = {'project': self.resource.project,
'resource': self.resource,
'language': self.language}
object_list = [self.resource.project, self.resource, self.language]
# if we got no user, skip the log
if user:
action_logging(user, object_list, nt, context=context)
if settings.ENABLE_NOTICES:
txnotification.send_observation_notices_for(self.resource.project,
def handle(self, **options):
from transifex.resources.models import Resource, SourceEntity, Translation
from transifex.resources.handlers import invalidate_stats_cache
en = Language.objects.get(code='en-US')
# for e in legacy.Extension.objects.filter(slug='smarttemplate4'):
for e in legacy.Extension.objects.filter(slug='babelzillamenu-13'):
owner = migrate_user(e.owner.username)
slug = NEW_SLUGS.get(e.slug, e.slug)
p, created = Project.objects.get_or_create(slug=slug,
defaults={
'name': smart_unicode(e.name),
'description': smart_unicode(e.description),
'homepage': e.homepage,
'source_language':en,
'owner': owner,
})
p.maintainers.add(owner)
# import Strings and Translations
for f in legacy.File.objects.filter(extension=e):
r, created = Resource.objects.get_or_create(name=f.name, project=p, slug=slugify(f.name))
if f.name.endswith('.dtd'):
r.i18n_type = 'DTD'
elif f.name.endswith('.properties'):
r.i18n_type = 'MOZILLAPROPERTIES'
else:
raise Exception("Unknown file type")
r.save()
for s in legacy.String.objects.filter(file=f, extension=e).select_related('language'):
entity, created = SourceEntity.objects.get_or_create(resource=r, string=s.name)
lang = LangLookup.get(s.language.name)
if not lang:
# pl_PL and ru_RU are actually never read when newer,
# shorter Languages like 'pl' and 'ru' are present
print "Language lookup failed for %s" % s.language.name
continue
try:
t, created = Translation.objects.get_or_create(
resource=r, source_entity=entity, language=lang
)
t.string = smart_unicode(s.string)
t.save()
except:
print "Error saving String {0}".format(s.id)
# reset Stats
for r in Resource.objects.filter(project=p):
for l in Language.objects.filter(pk__in=Translation.objects.filter(resource=r
).order_by('language').values_list('language', flat=True).distinct()):
invalidate_stats_cache(r, l)
# import Teams
for g in legacy.Group.objects.filter(extension=e):
l_members = legacy.Membership.objects.filter(group=g).order_by('permissions')
team_owner = migrate_user(e.owner.username)
try:
if l_members and l_members[0].permissions == 'm':
# members exist and first one is a maintainer
team_owner = migrate_user(l_members[0].user.username)
except legacy.User.DoesNotExist:
print "Invalid membership: %s" % l_members[0].id
lang = LangLookup.get(g.language.name)
team, created = Team.objects.get_or_create(language=lang, project=p,
defaults = {'creator': team_owner} )
for m in l_members:
try:
user = migrate_user(m.user.username)
except legacy.User.DoesNotExist:
print "Invalid membership: %s" % l_members[0].id
continue
if m.permissions == 'm':
team.coordinators.add(user)
else:
team.members.add(user)
def proofread(request,
project_slug,
lang_code,
resource_slug=None,
*args,
**kwargs):
"""AJAX view that sets the reviewed flag on Translations to true or false.
The request data is expected in JSON, with the following format:
{
'true': [1,2,3]
'false': [4,5]
}
Note: The IDs are source entity IDs.
"""
if request.method != 'POST':
return HttpResponse(status=405)
project = get_object_or_404(Project, slug=project_slug)
resource = get_object_or_404(Resource, slug=resource_slug, project=project)
try:
language = Language.objects.by_code_or_alias(lang_code)
except Language.DoesNotExist:
raise Http404
# Check if the user has the necessary permissions to review strings.
check = ProjectPermission(request.user)
if not check.proofread(project, language):
return permission_denied(request)
request_data = simplejson.loads(request.raw_post_data)
if 'true' in request_data:
source_entity_ids = request_data['true']
translations = Translation.objects.filter(
source_entity__id__in=source_entity_ids,
language__code=lang_code,
)
translations.update(reviewed=True)
ReviewHistory.add_many(translations,
request.user,
project.id,
reviewed=True)
if 'false' in request_data:
source_entity_ids = request_data['false']
translations = Translation.objects.filter(
source_entity__id__in=source_entity_ids,
language__code=lang_code,
)
translations.update(reviewed=False)
ReviewHistory.add_many(translations,
request.user,
project.id,
reviewed=False)
invalidate_stats_cache(resource, language, user=request.user)
return HttpResponse(status=200)
