ferme #459, moderation en lots (Valider et invalider)
[auf_savoirs_en_partage_django.git] / auf_savoirs_en_partage / savoirs / admin_views.py
1 # -*- encoding: utf-8 -*-
2 from django import forms
3 from django.http import HttpResponseRedirect
4 from django.core.urlresolvers import reverse
5 from django.contrib.auth.decorators import login_required
6 from django.template import Context, RequestContext
7 from django.shortcuts import render_to_response
8
9 from datamaster_modeles.models import Thematique, Pays, Region
10 from savoirs.models import Record, Discipline
11
12 # Dashboard
13 class RecordDashboard:
14 """Cette classe permet d'afficher une liste de tâche à faire en fonction de l'usagé"""
15 context = None
16
17 def __init__(self, context):
18 """Récupère le context"""
19 self.context = context
20
21 def get_fitre_serveurs(self,):
22 """Retourner la liste des serveurs sélectionnés.
23 S'il n'y en a pas, tous les serveurs sont retournés."""
24 try:
25 user = self.context.get('user')
26 profile = user.get_profile()
27 serveurs = profile.serveurs.all()
28 except:
29 serveurs = Serveur.objects.all()
30 return [s.nom for s in serveurs]
31
32 def total_a_faire(self,):
33 """Retourne le total des références à traiter"""
34 return len(self.tout_mes_records())
35
36 def tout_mes_records(self,):
37 """Retourne la liste des références à traiter en fonction du filtre"""
38 filtre = self.get_fitre_serveurs()
39 return [r for r in Record.objects.filter(server__in=filtre) if not r.est_complet()]
40
41 def mes_records(self,):
42 """Retourne la liste des références à traiter en fonction du filtre"""
43 return self.tout_mes_records()
44
45 def ref_apercu(self, record):
46 return "[%s] %s" % (record.server, record.title)
47
48 def change_url(self, object):
49 """Retourne l'url pour éditer le record"""
50 return reverse('admin:%s_%s_change' %(object._meta.app_label, object._meta.module_name), args=[object.id])
51
52 def a_traiter(self, ):
53 """Retourne la structure de données nécessaire pour le widget de django-admin-tool"""
54 records = self.mes_records()
55 return [{'title':self.ref_apercu(r), 'url':self.change_url(r), 'external': False} for r in records]
56
57 # Admin views pour les associations par lots
58
59 class PaysForm(forms.Form):
60 values = [(p.id, p.nom) for p in Pays.objects.all()]
61 pays = forms.MultipleChoiceField(choices=values)
62
63 class RegionsForm(forms.Form):
64 values = [(r.id, r.nom) for r in Region.objects.all()]
65 regions = forms.MultipleChoiceField(choices=values)
66
67 class ThematiquesForm(forms.Form):
68 values = [(t.id, t.nom) for t in Thematique.objects.all()]
69 thematiques = forms.MultipleChoiceField(choices=values)
70
71 class DisciplinesForm(forms.Form):
72 values = [(t.id, t.nom) for t in Discipline.objects.all()]
73 disciplines = forms.MultipleChoiceField(choices=values)
74
75 class ConfirmationForm(forms.Form):
76 pass
77
78 @login_required
79 def assigner_pays(request):
80 ids = request.GET.get("ids").split(",")
81 records = Record.objects.in_bulk(ids)
82 if request.method == 'POST':
83 pays_form = PaysForm(request.POST)
84
85 if pays_form.is_valid():
86
87 # charger tous les objets pays
88 pays = []
89 for pays_id in request.POST.getlist("pays"):
90 pays.append(Pays.objects.get(id=pays_id))
91
92 # assigner chaque pays à chaque référence
93 for r in records.values():
94 for p in pays:
95 r.pays.add(p)
96 r.save()
97
98 # retouner un status à l'utilisateur sur la liste des références
99 pays_noms = u", ".join([p.nom for p in pays])
100 succes = u"Les pays %s ont été assignés à %s références" % (pays_noms, len(ids))
101 request.user.message_set.create(message=succes)
102 return HttpResponseRedirect('/admin/savoirs/record')
103 else:
104 pays_form = PaysForm()
105
106 return render_to_response ("savoirs/assigner.html",
107 Context ({'records': records,
108 'form': pays_form,
109 'titre': u"Assignation de pays par lots",
110 'description': u"Sélectionner les pays qui seront associés aux références suivantes :" ,
111 }),
112 context_instance = RequestContext(request))
113
114 @login_required
115 def assigner_regions(request):
116 ids = request.GET.get("ids").split(",")
117 records = Record.objects.in_bulk(ids)
118 if request.method == 'POST':
119 regions_form = RegionsForm(request.POST)
120
121 if regions_form.is_valid():
122
123 # charger tous les objets regions
124 regions = []
125 for region_id in request.POST.getlist("regions"):
126 regions.append(Region.objects.get(id=region_id))
127
128 # assigner chaque regions à chaque référence
129 for r in records.values():
130 for p in regions:
131 r.regions.add(p)
132 r.save()
133
134 # retouner un status à l'utilisateur sur la liste des références
135 regions_noms = u", ".join([p.nom for p in regions])
136 succes = u"Les regions %s ont été assignées à %s références" % (regions_noms, len(ids))
137 request.user.message_set.create(message=succes)
138 return HttpResponseRedirect('/admin/savoirs/record')
139 else:
140 regions_form = RegionsForm()
141
142 return render_to_response ("savoirs/assigner.html",
143 Context ({'records': records,
144 'form': regions_form,
145 'titre': u"Assignation de régions par lots",
146 'description': u"Sélectionner les regions qui seront associées aux références suivantes :" ,
147 }),
148 context_instance = RequestContext(request))
149
150 @login_required
151 def assigner_disciplines(request):
152 ids = request.GET.get("ids").split(",")
153 records = Record.objects.in_bulk(ids)
154 if request.method == 'POST':
155 disciplines_form = DisciplinesForm(request.POST)
156
157 if disciplines_form.is_valid():
158
159 # charger tous les objets disciplines
160 disciplines = []
161 for discipline_id in request.POST.getlist("disciplines"):
162 disciplines.append(Discipline.objects.get(id=discipline_id))
163
164 # assigner chaque disciplines à chaque référence
165 for r in records.values():
166 for p in disciplines:
167 r.disciplines.add(p)
168 r.save()
169
170 # retouner un status à l'utilisateur sur la liste des références
171 disciplines_noms = u", ".join([p.nom for p in disciplines])
172 succes = u"Les disciplines %s ont été assignées à %s références" % (disciplines_noms, len(ids))
173 request.user.message_set.create(message=succes)
174 return HttpResponseRedirect('/admin/savoirs/record')
175 else:
176 disciplines_form = DisciplinesForm()
177
178 return render_to_response ("savoirs/assigner.html",
179 Context ({'records': records,
180 'form': disciplines_form,
181 'titre': u"Assignation de disciplines par lots",
182 'description': u"Sélectionner les disciplines qui seront associées aux références suivantes :" ,
183 }),
184 context_instance = RequestContext(request))
185
186 @login_required
187 def assigner_thematiques(request):
188 ids = request.GET.get("ids").split(",")
189 records = Record.objects.in_bulk(ids)
190 if request.method == 'POST':
191 thematiques_form = ThematiquesForm(request.POST)
192
193 if thematiques_form.is_valid():
194
195 # charger tous les objets thematiques
196 thematiques = []
197 for thematique_id in request.POST.getlist("thematiques"):
198 thematiques.append(Thematique.objects.get(id=thematique_id))
199
200 # assigner chaque thematiques à chaque référence
201 for r in records.values():
202 for p in thematiques:
203 r.thematiques.add(p)
204 r.save()
205
206 # retouner un status à l'utilisateur sur la liste des références
207 thematiques_noms = u", ".join([p.nom for p in thematiques])
208 succes = u"Les thématiques %s ont été assignées à %s références" % (thematiques_noms, len(ids))
209 request.user.message_set.create(message=succes)
210 return HttpResponseRedirect('/admin/savoirs/record')
211 else:
212 thematiques_form = ThematiquesForm()
213
214 return render_to_response ("savoirs/assigner.html",
215 Context ({'records': records,
216 'form': thematiques_form,
217 'titre': u"Assignation de thématiques par lots",
218 'description': u"Sélectionner les thématiques qui seront associées aux références suivantes :" ,
219 }),
220 context_instance = RequestContext(request))
221
222 @login_required
223 def confirmation(request, action):
224 ids = request.GET.get("ids").split(",")
225
226 # determination du contexte de validation
227 if action == u'valider':
228 records = [r for r in Record.objects.in_bulk(ids).values() if r.est_complet()]
229 desc = u'validées'
230 validated = True
231 elif action == u'invalider':
232 records = Record.objects.in_bulk(ids).values()
233 desc = u'invalidées'
234 validated = False
235 else:
236 raise Exception("action invalide %s " % action)
237
238 if request.method == 'POST':
239 confirmation_form = ConfirmationForm(request.POST)
240
241 if confirmation_form.is_valid():
242 for r in records:
243 r.validated = validated
244 r.save()
245
246 succes = u""u"Les références ont été %s" % desc
247 request.user.message_set.create(message=succes)
248 return HttpResponseRedirect('/admin/savoirs/record')
249 else:
250 confirmation_form = ConfirmationForm()
251
252
253 return render_to_response ("savoirs/confirmation.html",
254 Context ({'records': records,
255 'action': action,
256 'form': confirmation_form,
257 'titre': u"Validation par lots",
258 'description': u"Les références suivantes vont être %s:" % desc ,
259 }),
260 context_instance = RequestContext(request))