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
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
15 class RecordDashboard
:
16 """Cette classe permet d'afficher une liste de tâche à faire en fonction de l'usagé"""
19 def __init__(self
, context
):
20 """Récupère le context"""
21 self
.context
= context
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."""
27 user
= self
.context
.get('user')
28 profile
= user
.get_profile()
29 serveurs
= profile
.serveurs
.all()
31 serveurs
= Serveur
.objects
.all()
32 return [s
.nom
for s
in serveurs
]
34 def total_a_faire(self
,):
35 """Retourne le total des références à traiter"""
36 return len(self
.tout_mes_records())
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()]
43 def mes_records(self
,):
44 """Retourne la liste des références à traiter en fonction du filtre"""
45 return self
.tout_mes_records()
47 def ref_apercu(self
, record
):
48 return "[%s] %s" % (record
.server
, record
.title
)
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])
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
]
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
)
66 if pays_form
.is_valid():
68 # charger tous les objets pays
70 for pays_id
in request
.POST
.getlist("pays"):
71 pays
.append(Pays
.objects
.get(id=pays_id
))
73 # assigner chaque pays à chaque référence
74 for r
in records
.values():
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')
85 pays_form
= PaysForm()
87 return render_to_response ("savoirs/assigner.html",
88 Context ({'records': records
,
90 'titre': u
"Assignation de pays par lots",
91 'description': u
"Sélectionner les pays qui seront associés aux références suivantes :" ,
93 context_instance
= RequestContext(request
))
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
)
103 if regions_form
.is_valid():
104 regions
= regions_form
.cleaned_data
['regions']
106 o
.assigner_regions(regions
)
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
)))
115 regions_form
= RegionsForm()
116 return render_to_response(
117 "savoirs/assigner.html",
118 dict(objects
=objects
,
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
)
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
)
133 if disciplines_form
.is_valid():
134 disciplines
= disciplines_form
.cleaned_data
['disciplines']
136 o
.assigner_disciplines(disciplines
)
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
)))
145 disciplines_form
= DisciplinesForm()
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
)
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
)
163 if thematiques_form
.is_valid():
165 # charger tous les objets thematiques
167 for thematique_id
in request
.POST
.getlist("thematiques"):
168 thematiques
.append(Thematique
.objects
.get(id=thematique_id
))
170 # assigner chaque thematiques à chaque référence
171 for r
in records
.values():
172 for p
in thematiques
:
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')
182 thematiques_form
= ThematiquesForm()
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 :" ,
190 context_instance
= RequestContext(request
))
193 def confirmation(request
, action
):
194 ids
= request
.GET
.get("ids").split(",")
195 type, action
= action
.split('/')[0:2]
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)
202 model
= u
'références'
204 elif action
== u
'invalider':
205 objects
= Record
.objects
.in_bulk(ids
).values()
206 action
= ('validated', False)
208 model
= u
'références'
210 elif action
== u
'visible':
211 objects
= Actualite
.objects
.in_bulk(ids
).values()
212 action
= ('visible', True)
214 model
= u
'actualités'
216 elif action
== u
'invisible':
217 objects
= Actualite
.objects
.in_bulk(ids
).values()
218 action
= ('visible', False)
220 model
= u
'actualités'
223 raise Exception("action invalide %s " % action
)
225 if request
.method
== 'POST':
226 confirmation_form
= ConfirmationForm(request
.POST
)
228 if confirmation_form
.is_valid():
230 setattr(o
, action
[0], action
[1])
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)
237 confirmation_form
= ConfirmationForm()
240 return render_to_response ("savoirs/confirmation.html",
241 Context ({'objects': objects
,
243 'form': confirmation_form
,
244 'titre': u
"Validation par lots",
245 'description': u
"Les %s suivantes vont être %s:" % (model
, desc
) ,
247 context_instance
= RequestContext(request
))