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