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))