This repository has been archived by the owner on Mar 15, 2018. It is now read-only.
/
views.py
186 lines (152 loc) · 6.29 KB
/
views.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
from itertools import groupby
from django.conf import settings
from django.core.exceptions import PermissionDenied
from django.shortcuts import redirect
import commonware.log
import jingo
from product_details import product_details
import amo
from access.models import Group
from addons.models import Category
from amo.decorators import json_view, login_required, post_required, write
from amo.urlresolvers import reverse
from amo.utils import no_translation
from translations.models import Translation
from .decorators import locale_switcher, valid_locale
from .forms import CategoryFormSet
from .helpers import _permission_to_edit_locale
from .models import L10nSettings
log = commonware.log.getLogger('z.l10n')
@write
@login_required
@post_required
@json_view
def set_motd(request):
"""AJAX: Set announcements for either global or per-locale dashboards."""
lang = request.POST.get('lang')
msg = request.POST.get('msg')
if (lang != '' and lang not in settings.AMO_LANGUAGES and
lang not in settings.HIDDEN_LANGUAGES or msg is None):
return json_view.error(_('An error occurred saving this message.'))
if _permission_to_edit_locale(lang):
return json_view.error(_('Access Denied'))
l10n_set, created = L10nSettings.objects.get_or_create(locale=lang)
# MOTDs are monolingual, so always store them in the default fallback
# locale (probably en-US)
l10n_set.motd = {settings.LANGUAGE_CODE: msg}
l10n_set.save(force_update=True)
log.info("Changing MOTD for (%s) to (%s)", lang or 'global', msg)
data = {
'msg': l10n_set.motd.localized_string,
'msg_purified': unicode(l10n_set.motd)
}
return data
def summary(request):
"""global L10n dashboard"""
data = {
'languages': product_details.languages,
'amo_languages': sorted(settings.AMO_LANGUAGES +
settings.HIDDEN_LANGUAGES),
'hidden_languages': settings.HIDDEN_LANGUAGES,
}
return jingo.render(request, 'localizers/summary.html', data)
@locale_switcher
@valid_locale
def locale_dashboard(request, locale_code):
"""per-locale dashboard"""
data = {
'locale_code': locale_code,
'userlang': product_details.languages[locale_code],
}
# group members
try:
group = Group.objects.get(
rules__startswith=('Locale.%s:' % locale_code))
members = group.users.all()
except Group.DoesNotExist:
members = None
data['members'] = members
# team homepage
try:
l10n_set = L10nSettings.objects.get(locale=locale_code)
team_homepage = l10n_set.team_homepage
except L10nSettings.DoesNotExist:
team_homepage = None
data['team_homepage'] = team_homepage
return jingo.render(request, 'localizers/dashboard.html', data)
@locale_switcher
@valid_locale
@login_required
def categories(request, locale_code):
if not _permission_to_edit_locale(request, locale_code):
raise PermissionDenied
with no_translation():
cats = list(Category.objects.order_by('application'))
strings = dict(Translation.objects.filter(
id__in=[c.name_id for c in cats], locale=locale_code)
.values_list('id', 'localized_string'))
# Category ID to localized string map for checking for changes.
category_names = dict([(c.id, strings.get(c.name_id)) for c in cats])
# Category ID to model object to avoid extra SQL lookups on POST.
category_objects = dict([(c.id, c) for c in cats])
# Initial data to pre-populate forms.
initial = [dict(id=c.id, name=strings.get(c.name_id),
application=c.application_id) for c in cats]
# Group categories by application, and sort by name within app groups.
categories = []
category_no_app = None
for key, group in groupby(cats, lambda c: c.application_id):
sorted_cats = sorted(group, key=lambda c: c.name)
if key:
categories.append((key, sorted_cats))
else:
category_no_app = (key, sorted_cats)
if category_no_app: # Put app-less categories at the bottom.
categories.append(category_no_app)
formset = CategoryFormSet(request.POST or None, initial=initial)
# Category ID to form mapping.
form_map = dict((form.initial['id'], form) for form in formset.forms)
if request.method == 'POST' and formset.is_valid():
for form in formset:
pk = form.cleaned_data.get('id')
name = form.cleaned_data.get('name')
if name != category_names.get(pk):
cat = category_objects.get(pk)
if not cat:
continue
# The localized string has changed.
# Make sure we don't save an empty string value.
if name == '' and category_names.get(pk) == None:
# If the form field was left blank and there was no
# previous translation, do nothing.
continue
elif name == '' and category_names.get(pk) != None:
# If the name is blank and there was a prior translation,
# assume they want to remove this translation.
#
# TODO(robhudson): Figure out how to delete a single
# translation properly. Calling...
#
# Translation.objects.filter(id=cat.name.id,
# locale=locale_code).delete()
#
# ...results in some crazy db traversal that tries to
# delete all kinds of things.
pass
else:
# Otherwise, name is not empty and it had a prior
# translation so update it.
cat.name = {locale_code: name}
cat.save()
return redirect(reverse('localizers.categories',
kwargs=dict(locale_code=locale_code)))
data = {
'locale_code': locale_code,
'userlang': product_details.languages[locale_code],
'categories': categories,
'formset': formset,
'form_map': form_map,
'apps': amo.APP_IDS,
'types': amo.ADDON_TYPE,
}
return jingo.render(request, 'localizers/categories.html', data)