076bfd229109def4b9e688a2f8fc4f6c1bfa2d74
[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.db.models import get_model, Count
4 from django.http import HttpResponseRedirect
5 from django.core.urlresolvers import reverse as url
6 from django.contrib.auth.decorators import login_required
7 from django.template import Context, RequestContext
8 from django.shortcuts import render_to_response
9
10 from chercheurs.models import Chercheur, Groupe
11 from datamaster_modeles.models import Thematique, Pays, Region
12 from savoirs.models import Record, Discipline, Actualite, Serveur
13 from savoirs.forms import PaysForm, RegionsForm, ThematiquesForm, DisciplinesForm, ConfirmationForm
14
15 # Dashboard
16 class RecordDashboard:
17 """Cette classe permet d'afficher une liste de tâche à faire en fonction de l'usagé"""
18 context = None
19
20 def __init__(self, context):
21 """Récupère le context"""
22 self.context = context
23
24 def get_fitre_serveurs(self,):
25 """Retourner la liste des serveurs sélectionnés.
26 S'il n'y en a pas, tous les serveurs sont retournés."""
27 try:
28 user = self.context.get('user')
29 profile = user.get_profile()
30 serveurs = profile.serveurs.all()
31 except:
32 serveurs = Serveur.objects.all()
33 return [s.nom for s in serveurs]
34
35 def total_a_faire(self,):
36 """Retourne le total des références à traiter"""
37 return len(self.tout_mes_records())
38
39 def tout_mes_records(self,):
40 """Retourne la liste des références à traiter en fonction du filtre"""
41 filtre = self.get_fitre_serveurs()
42 return [r for r in Record.all_objects.filter(server__in=filtre) if not r.est_complet()]
43
44 def mes_records(self,):
45 """Retourne la liste des références à traiter en fonction du filtre"""
46 return self.tout_mes_records()
47
48 def ref_apercu(self, record):
49 return "[%s] %s" % (record.server, record.title)
50
51 def change_url(self, object):
52 """Retourne l'url pour éditer le record"""
53 return url('admin:%s_%s_change' %(object._meta.app_label, object._meta.module_name), args=[object.id])
54
55 def a_traiter(self, ):
56 """Retourne la structure de données nécessaire pour le widget de django-admin-tool"""
57 records = self.mes_records()
58 return [{'title':self.ref_apercu(r), 'url':self.change_url(r), 'external': False} for r in records]
59
60 @login_required
61 def assigner_pays(request):
62 ids = request.GET.get("ids").split(",")
63 records = Record.all_objects.in_bulk(ids)
64 if request.method == 'POST':
65 pays_form = PaysForm(request.POST)
66
67 if pays_form.is_valid():
68
69 # charger tous les objets pays
70 pays = []
71 for pays_id in request.POST.getlist("pays"):
72 pays.append(Pays.objects.get(id=pays_id))
73
74 # assigner chaque pays à chaque référence
75 for r in records.values():
76 for p in pays:
77 r.pays.add(p)
78 r.save()
79
80 # retouner un status à l'utilisateur sur la liste des références
81 pays_noms = u", ".join([p.nom for p in pays])
82 succes = u"Les pays %s ont été assignés à %s références" % (pays_noms, len(ids))
83 request.user.message_set.create(message=succes)
84 return HttpResponseRedirect('/admin/savoirs/record')
85 else:
86 pays_form = PaysForm()
87
88 return render_to_response ("savoirs/assigner.html",
89 Context ({'records': records,
90 'form': pays_form,
91 'titre': u"Assignation de pays par lots",
92 'description': u"Sélectionner les pays qui seront associés aux références suivantes :" ,
93 }),
94 context_instance = RequestContext(request))
95
96 @login_required
97 def assigner_regions(request, app_name, model_name):
98 ids = request.GET.get("ids").split(",")
99 model = get_model(app_name, model_name)
100 objects = model.objects.filter(pk__in=ids)
101 if request.method == 'POST':
102 regions_form = RegionsForm(request.POST)
103
104 if regions_form.is_valid():
105 regions = regions_form.cleaned_data['regions']
106 for o in objects:
107 o.assigner_regions(regions)
108 o.save()
109
110 # retouner un status à l'utilisateur sur la liste des références
111 regions_noms = u", ".join([p.nom for p in regions])
112 succes = u"Les regions %s ont été assignées à %s objets" % (regions_noms, len(ids))
113 request.user.message_set.create(message=succes)
114 return HttpResponseRedirect(url('admin:%s_%s_changelist' % (app_name, model_name)))
115 else:
116 regions_form = RegionsForm()
117 return render_to_response(
118 "savoirs/assigner.html",
119 dict(objects=objects,
120 form=regions_form,
121 titre=u"Assignation de régions par lots",
122 description=u"Sélectionner les régions qui seront associées aux références suivantes :"),
123 context_instance = RequestContext(request)
124 )
125
126 @login_required
127 def assigner_disciplines(request, app_name, model_name):
128 ids = request.GET.get("ids").split(",")
129 model = get_model(app_name, model_name)
130 objects = model.objects.filter(pk__in=ids)
131 if request.method == 'POST':
132 disciplines_form = DisciplinesForm(request.POST)
133
134 if disciplines_form.is_valid():
135 disciplines = disciplines_form.cleaned_data['disciplines']
136 for o in objects:
137 o.assigner_disciplines(disciplines)
138 o.save()
139
140 # retouner un status à l'utilisateur sur la liste des références
141 disciplines_noms = u", ".join([p.nom for p in disciplines])
142 succes = u"Les disciplines %s ont été assignées à %s objets" % (disciplines_noms, len(ids))
143 request.user.message_set.create(message=succes)
144 return HttpResponseRedirect(url('admin:%s_%s_changelist' % (app_name, model_name)))
145 else:
146 disciplines_form = DisciplinesForm()
147
148 return render_to_response(
149 "savoirs/assigner.html",
150 dict(objects=objects,
151 form=disciplines_form,
152 titre=u"Assignation de disciplines par lots",
153 description=u"Sélectionner les disciplines qui seront associées aux références suivantes :"),
154 context_instance = RequestContext(request)
155 )
156
157 @login_required
158 def assigner_thematiques(request):
159 ids = request.GET.get("ids").split(",")
160 records = Record.all_objects.in_bulk(ids)
161 if request.method == 'POST':
162 thematiques_form = ThematiquesForm(request.POST)
163
164 if thematiques_form.is_valid():
165
166 # charger tous les objets thematiques
167 thematiques = []
168 for thematique_id in request.POST.getlist("thematiques"):
169 thematiques.append(Thematique.objects.get(id=thematique_id))
170
171 # assigner chaque thematiques à chaque référence
172 for r in records.values():
173 for p in thematiques:
174 r.thematiques.add(p)
175 r.save()
176
177 # retouner un status à l'utilisateur sur la liste des références
178 thematiques_noms = u", ".join([p.nom for p in thematiques])
179 succes = u"Les thématiques %s ont été assignées à %s références" % (thematiques_noms, len(ids))
180 request.user.message_set.create(message=succes)
181 return HttpResponseRedirect('/admin/savoirs/record')
182 else:
183 thematiques_form = ThematiquesForm()
184
185 return render_to_response ("savoirs/assigner.html",
186 Context ({'records': records,
187 'form': thematiques_form,
188 'titre': u"Assignation de thématiques par lots",
189 'description': u"Sélectionner les thématiques qui seront associées aux références suivantes :" ,
190 }),
191 context_instance = RequestContext(request))
192
193 @login_required
194 def confirmation(request, action):
195 ids = request.GET.get("ids").split(",")
196 type, action = action.split('/')[0:2]
197
198 # determination du contexte de validation
199 if action == u'valider':
200 objects = [r for r in Record.all_objects.in_bulk(ids).values() if r.est_complet()]
201 action = ('validated', True)
202 desc = u'validées'
203 model = u'références'
204
205 elif action == u'invalider':
206 objects = Record.all_objects.in_bulk(ids).values()
207 action = ('validated', False)
208 desc = u'invalidées'
209 model = u'références'
210
211 elif action == u'visible':
212 objects = Actualite.all_objects.in_bulk(ids).values()
213 action = ('visible', True)
214 desc = u'visibles'
215 model = u'actualités'
216
217 elif action == u'invisible':
218 objects = Actualite.all_objects.in_bulk(ids).values()
219 action = ('visible', False)
220 desc = u'invisibles'
221 model = u'actualités'
222
223 else:
224 raise Exception("action invalide %s " % action)
225
226 if request.method == 'POST':
227 confirmation_form = ConfirmationForm(request.POST)
228
229 if confirmation_form.is_valid():
230 for o in objects:
231 setattr(o, action[0], action[1])
232 o.save()
233
234 succes = u""u"Les références ont été %s" % desc
235 request.user.message_set.create(message=succes)
236 return HttpResponseRedirect('/admin/savoirs/%s' % type)
237 else:
238 confirmation_form = ConfirmationForm()
239
240
241 return render_to_response ("savoirs/confirmation.html",
242 Context ({'objects': objects,
243 'action': action,
244 'form': confirmation_form,
245 'titre': u"Validation par lots",
246 'description': u"Les %s suivantes vont être %s:" % (model, desc) ,
247 }),
248 context_instance = RequestContext(request))
249
250 # Stats
251
252 def stats(request):
253
254 def mises_a_jour(qs):
255 return qs.filter(date_modification__gte='2010-11-17').count()
256
257 def par_region(qs):
258 qs = qs.extra(select={
259 'region': '''(SELECT p.region FROM ref_pays p
260 WHERE p.code = CASE WHEN chercheurs_chercheur.etablissement IS NULL
261 THEN chercheurs_chercheur.etablissement_autre_pays
262 ELSE (SELECT e.pays FROM ref_etablissement e
263 WHERE e.id = chercheurs_chercheur.etablissement) END)'''
264 })
265 return dict(qs.values_list('region').annotate(count=Count('pk')))
266
267 def par_hemisphere(qs):
268 qs = qs.extra(select={
269 'hemisphere': '''(SELECT p.nord_sud FROM ref_pays p
270 WHERE p.code = CASE WHEN chercheurs_chercheur.etablissement IS NULL
271 THEN chercheurs_chercheur.etablissement_autre_pays
272 ELSE (SELECT e.pays FROM ref_etablissement e
273 WHERE e.id = chercheurs_chercheur.etablissement) END)'''
274 })
275 return dict(qs.values_list('hemisphere').annotate(count=Count('pk')))
276
277 def par_discipline(qs):
278 return dict(qs.values_list('discipline').annotate(count=Count('pk')))
279
280 def par_domaine(qs):
281 qs = qs.extra(tables=['chercheurs_chercheurgroupe'],
282 where=['chercheurs_chercheurgroupe.chercheur = chercheurs_chercheur.personne_ptr_id'],
283 select={'groupe': 'chercheurs_chercheurgroupe.groupe'})
284 return dict(qs.values_list('groupe').annotate(count=Count('pk')))
285
286 chercheurs = Chercheur.objects
287 hommes = chercheurs.filter(genre='m')
288 femmes = chercheurs.filter(genre='f')
289 return render_to_response(
290 'savoirs/stats.html', {
291 'nb_chercheurs': chercheurs.count(),
292 'nb_hommes': hommes.count(),
293 'nb_femmes': femmes.count(),
294 'mises_a_jour': mises_a_jour(chercheurs),
295 'mises_a_jour_hommes': mises_a_jour(hommes),
296 'mises_a_jour_femmes': mises_a_jour(femmes),
297 'regions': Region.objects.order_by('nom'),
298 'chercheurs_par_region': par_region(chercheurs),
299 'hommes_par_region': par_region(hommes),
300 'femmes_par_region': par_region(femmes),
301 'hemispheres': ['Nord', 'Sud'],
302 'chercheurs_par_hemisphere': par_hemisphere(chercheurs),
303 'hommes_par_hemisphere': par_hemisphere(hommes),
304 'femmes_par_hemisphere': par_hemisphere(femmes),
305 'disciplines': Discipline.objects.order_by('nom'),
306 'chercheurs_par_discipline': par_discipline(chercheurs),
307 'hommes_par_discipline': par_discipline(hommes),
308 'femmes_par_discipline': par_discipline(femmes),
309 'domaines': Groupe.objects.order_by('nom'),
310 'chercheurs_par_domaine': par_domaine(chercheurs),
311 'hommes_par_domaine': par_domaine(hommes),
312 'femmes_par_domaine': par_domaine(femmes),
313 }, context_instance=RequestContext(request)
314 )