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
  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
  33     def total_a_faire(self,):
  34         """Retourne le total des références à traiter"""
  35         return len(self.tout_mes_records())
  36
  37     def tout_mes_records(self,):
  38         """Retourne la liste des références à traiter en fonction du filtre"""
  39         filtre = self.get_fitre_serveurs()
  40         return [r for r in Record.objects.filter(server__in=filtre) if not r.est_complet()]
  41
  42     def mes_records(self,):
  43         """Retourne la liste des références à traiter en fonction du filtre"""
  44         return self.tout_mes_records()
  45
  46     def ref_apercu(self, record):
  47         return "[%s] %s" % (record.server, record.title)
  48
  49     def change_url(self, object):
  50         """Retourne l'url pour éditer le record"""
  51         return reverse('admin:%s_%s_change' %(object._meta.app_label, object._meta.module_name), args=[object.id])
  52
  53     def a_traiter(self, ):
  54         """Retourne la structure de données nécessaire pour le widget de django-admin-tool"""
  55         records = self.mes_records()
  56         return [{'title':self.ref_apercu(r), 'url':self.change_url(r), 'external': False} for r in records]
  57
  58 # Admin views pour les associations par lots
  59
  60 class PaysForm(forms.Form):
  61     values = [(p.id, p.nom) for p in Pays.objects.all()]
  62     pays = forms.MultipleChoiceField(choices=values)
  63
  64 class RegionsForm(forms.Form):
  65     values = [(r.id, r.nom) for r in Region.objects.all()]
  66     regions = forms.MultipleChoiceField(choices=values)
  67
  68 class ThematiquesForm(forms.Form):
  69     values = [(t.id, t.nom) for t in Thematique.objects.all()]
  70     thematiques = forms.MultipleChoiceField(choices=values)
  71
  72 class DisciplinesForm(forms.Form):
  73     values = [(t.id, t.nom) for t in Discipline.objects.all()]
  74     disciplines = forms.MultipleChoiceField(choices=values)
  75
  76
  77 @login_required
  78 def assigner_pays(request):
  79     ids = request.GET.get("ids").split(",")
  80     records = Record.objects.in_bulk(ids)
  81     if request.method == 'POST':
  82         pays_form = PaysForm(request.POST)
  83
  84         if pays_form.is_valid():
  85
  86             # charger tous les objets pays
  87             pays = []
  88             for pays_id in request.POST.getlist("pays"):
  89                 pays.append(Pays.objects.get(id=pays_id))
  90
  91             # assigner chaque pays à chaque référence
  92             for r in records.values():
  93                 for p in pays:
  94                     r.pays.add(p)
  95                 r.save()
  96
  97             # retouner un status à l'utilisateur sur la liste des références
  98             pays_noms = u", ".join([p.nom for p in pays])
  99             succes = u"Les pays %s ont été assignés à %s références" % (pays_noms, len(ids))
 100             request.user.message_set.create(message=succes)
 101             return HttpResponseRedirect('/admin/savoirs/record')
 102     else:
 103         pays_form = PaysForm()
 104
 105     return render_to_response ("savoirs/assigner.html",
 106             Context ({'records': records,
 107                       'form': pays_form,
 108                       'titre': u"Assignation de pays par lots",
 109                       'description': u"Sélectionner les pays qui seront associés aux références suivantes :" ,
 110                       }),
 111                      context_instance = RequestContext(request))
 112
 113 @login_required
 114 def assigner_regions(request):
 115     ids = request.GET.get("ids").split(",")
 116     records = Record.objects.in_bulk(ids)
 117     if request.method == 'POST':
 118         regions_form = RegionsForm(request.POST)
 119
 120         if regions_form.is_valid():
 121
 122             # charger tous les objets regions
 123             regions = []
 124             for region_id in request.POST.getlist("regions"):
 125                 regions.append(Region.objects.get(id=region_id))
 126
 127             # assigner chaque regions à chaque référence
 128             for r in records.values():
 129                 for p in regions:
 130                     r.regions.add(p)
 131                 r.save()
 132
 133             # retouner un status à l'utilisateur sur la liste des références
 134             regions_noms = u", ".join([p.nom for p in regions])
 135             succes = u"Les regions %s ont été assignées à %s références" % (regions_noms, len(ids))
 136             request.user.message_set.create(message=succes)
 137             return HttpResponseRedirect('/admin/savoirs/record')
 138     else:
 139         regions_form = RegionsForm()
 140
 141     return render_to_response ("savoirs/assigner.html",
 142             Context ({'records': records,
 143                       'form': regions_form,
 144                       'titre': u"Assignation de régions par lots",
 145                       'description': u"Sélectionner les regions qui seront associées aux références suivantes :" ,
 146                       }),
 147                      context_instance = RequestContext(request))
 148
 149 @login_required
 150 def assigner_disciplines(request):
 151     ids = request.GET.get("ids").split(",")
 152     records = Record.objects.in_bulk(ids)
 153     if request.method == 'POST':
 154         disciplines_form = DisciplinesForm(request.POST)
 155
 156         if disciplines_form.is_valid():
 157
 158             # charger tous les objets disciplines
 159             disciplines = []
 160             for discipline_id in request.POST.getlist("disciplines"):
 161                 disciplines.append(Discipline.objects.get(id=discipline_id))
 162
 163             # assigner chaque disciplines à chaque référence
 164             for r in records.values():
 165                 for p in disciplines:
 166                     r.disciplines.add(p)
 167                 r.save()
 168
 169             # retouner un status à l'utilisateur sur la liste des références
 170             disciplines_noms = u", ".join([p.nom for p in disciplines])
 171             succes = u"Les disciplines %s ont été assignées à %s références" % (disciplines_noms, len(ids))
 172             request.user.message_set.create(message=succes)
 173             return HttpResponseRedirect('/admin/savoirs/record')
 174     else:
 175         disciplines_form = DisciplinesForm()
 176
 177     return render_to_response ("savoirs/assigner.html",
 178             Context ({'records': records,
 179                       'form': disciplines_form,
 180                       'titre': u"Assignation de disciplines par lots",
 181                       'description': u"Sélectionner les disciplines qui seront associées aux références suivantes :" ,
 182                       }),
 183                      context_instance = RequestContext(request))
 184
 185 @login_required
 186 def assigner_thematiques(request):
 187     ids = request.GET.get("ids").split(",")
 188     records = Record.objects.in_bulk(ids)
 189     if request.method == 'POST':
 190         thematiques_form = ThematiquesForm(request.POST)
 191
 192         if thematiques_form.is_valid():
 193
 194             # charger tous les objets thematiques
 195             thematiques = []
 196             for thematique_id in request.POST.getlist("thematiques"):
 197                 thematiques.append(Thematique.objects.get(id=thematique_id))
 198
 199             # assigner chaque thematiques à chaque référence
 200             for r in records.values():
 201                 for p in thematiques:
 202                     r.thematiques.add(p)
 203                 r.save()
 204
 205             # retouner un status à l'utilisateur sur la liste des références
 206             thematiques_noms = u", ".join([p.nom for p in thematiques])
 207             succes = u"Les thématiques %s ont été assignées à %s références" % (thematiques_noms, len(ids))
 208             request.user.message_set.create(message=succes)
 209             return HttpResponseRedirect('/admin/savoirs/record')
 210     else:
 211         thematiques_form = ThematiquesForm()
 212
 213     return render_to_response ("savoirs/assigner.html",
 214             Context ({'records': records,
 215                       'form': thematiques_form,
 216                       'titre': u"Assignation de thématiques par lots",
 217                       'description': u"Sélectionner les thématiques qui seront associées aux références suivantes :" ,
 218                       }),
 219                      context_instance = RequestContext(request))