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, Actualite, Serveur
  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     type, action  = action.split('/')[0:2]
 226
 227     # determination du contexte de validation
 228     if action == u'valider':
 229         objects = [r for r in Record.objects.in_bulk(ids).values() if r.est_complet()]
 230         action = ('validated', True)
 231         desc = u'validées'
 232         model = u'références'
 233
 234     elif action == u'invalider':
 235         objects = Record.objects.in_bulk(ids).values()
 236         action = ('validated', False)
 237         desc = u'invalidées'
 238         model = u'références'
 239
 240     elif action == u'visible':
 241         objects = Actualite.objects.in_bulk(ids).values()
 242         action = ('visible', True)
 243         desc = u'visibles'
 244         model = u'actualités'
 245
 246     elif action == u'invisible':
 247         objects = Actualite.objects.in_bulk(ids).values()
 248         action = ('visible', False)
 249         desc = u'invisibles'
 250         model = u'actualités'
 251
 252     else:
 253        raise Exception("action invalide %s " % action)
 254
 255     if request.method == 'POST':
 256         confirmation_form = ConfirmationForm(request.POST)
 257
 258         if confirmation_form.is_valid():
 259             for o in objects:
 260                 setattr(o, action[0], action[1])
 261                 o.save()
 262
 263             succes = u""u"Les références ont été %s" % desc
 264             request.user.message_set.create(message=succes)
 265             return HttpResponseRedirect('/admin/savoirs/%s' % type)
 266     else:
 267         confirmation_form = ConfirmationForm()
 268
 269
 270     return render_to_response ("savoirs/confirmation.html",
 271             Context ({'objects': objects,
 272                       'action': action,
 273                       'form': confirmation_form,
 274                       'titre': u"Validation par lots",
 275                       'description': u"Les %s suivantes vont être %s:" % (model, desc) ,
 276                       }),
 277                      context_instance = RequestContext(request))