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