Assigner les disciplines et régions en bloc dans l'admin
[auf_savoirs_en_partage_django.git] / auf_savoirs_en_partage / savoirs / admin_views.py
index f9f8a44..4ddcc35 100644 (file)
@@ -1,31 +1,60 @@
 # -*- encoding: utf-8 -*-
 from django import forms
+from django.db.models import get_model
 from django.http import HttpResponseRedirect
+from django.core.urlresolvers import reverse as url
 from django.contrib.auth.decorators import login_required
 from django.template import Context, RequestContext
 from django.shortcuts import render_to_response
 
 from datamaster_modeles.models import Thematique, Pays, Region
-from savoirs.models import Record, Discipline
-
-# Admin views pour les associations par lots
-
-class PaysForm(forms.Form):
-    values = [(p.id, p.nom) for p in Pays.objects.all()]
-    pays = forms.MultipleChoiceField(choices=values)
-
-class RegionsForm(forms.Form):
-    values = [(r.id, r.nom) for r in Region.objects.all()]
-    regions = forms.MultipleChoiceField(choices=values)
-
-class ThematiquesForm(forms.Form):
-    values = [(t.id, t.nom) for t in Thematique.objects.all()]
-    thematiques = forms.MultipleChoiceField(choices=values)
-
-class DisciplinesForm(forms.Form):
-    values = [(t.id, t.nom) for t in Discipline.objects.all()]
-    disciplines = forms.MultipleChoiceField(choices=values)
+from savoirs.models import Record, Discipline, Actualite, Serveur
+from savoirs.forms import PaysForm, RegionsForm, ThematiquesForm, DisciplinesForm, ConfirmationForm
+
+# Dashboard
+class RecordDashboard:
+    """Cette classe permet d'afficher une liste de tâche à faire en fonction de l'usagé"""
+    context = None
+
+    def __init__(self, context):
+        """Récupère le context"""
+        self.context = context
+
+    def get_fitre_serveurs(self,):
+        """Retourner la liste des serveurs sélectionnés.
+        S'il n'y en a pas, tous les serveurs sont retournés."""
+        try:
+            user = self.context.get('user')
+            profile = user.get_profile()
+            serveurs =  profile.serveurs.all()
+        except:
+            serveurs = Serveur.objects.all()
+        return [s.nom for s in serveurs]
+
+    def total_a_faire(self,):
+        """Retourne le total des références à traiter"""
+        return len(self.tout_mes_records())
+
+    def tout_mes_records(self,):
+        """Retourne la liste des références à traiter en fonction du filtre"""
+        filtre = self.get_fitre_serveurs()
+        return [r for r in Record.objects.filter(server__in=filtre) if not r.est_complet()]
+    
+    def mes_records(self,):
+        """Retourne la liste des références à traiter en fonction du filtre"""
+        return self.tout_mes_records()
+
+    def ref_apercu(self, record):
+        return "[%s] %s" % (record.server, record.title)
+
+    def change_url(self, object):
+        """Retourne l'url pour éditer le record"""
+        return url('admin:%s_%s_change' %(object._meta.app_label, object._meta.module_name), args=[object.id])
+
+    def a_traiter(self, ):
+        """Retourne la structure de données nécessaire pour le widget de django-admin-tool"""
+        records = self.mes_records()
+        return [{'title':self.ref_apercu(r), 'url':self.change_url(r), 'external': False} for r in records]
 
 @login_required
 def assigner_pays(request):
@@ -64,76 +93,65 @@ def assigner_pays(request):
                      context_instance = RequestContext(request))
 
 @login_required
-def assigner_regions(request):
+def assigner_regions(request, app_name, model_name):
     ids = request.GET.get("ids").split(",")
-    records = Record.objects.in_bulk(ids)
+    model = get_model(app_name, model_name)
+    objects = model.objects.filter(pk__in=ids)
     if request.method == 'POST':
         regions_form = RegionsForm(request.POST)
 
         if regions_form.is_valid():
+            regions = regions_form.cleaned_data['regions']
+            for o in objects:
+                o.assigner_regions(regions)
+                o.save() 
 
-            # charger tous les objets regions
-            regions = []
-            for region_id in request.POST.getlist("regions"):
-                regions.append(Region.objects.get(id=region_id))
-
-            # assigner chaque regions à chaque référence
-            for r in records.values():
-                for p in regions:
-                    r.regions.add(p)
-                r.save()
-            
             # retouner un status à l'utilisateur sur la liste des références
             regions_noms = u", ".join([p.nom for p in regions])
-            succes = u"Les regions %s ont été assignées à %s références" % (regions_noms, len(ids))
+            succes = u"Les regions %s ont été assignées à %s objets" % (regions_noms, len(ids))
             request.user.message_set.create(message=succes)
-            return HttpResponseRedirect('/admin/savoirs/record')
+            return HttpResponseRedirect(url('admin:%s_%s_changelist' % (app_name, model_name)))
     else:
         regions_form = RegionsForm()
-
-    return render_to_response ("savoirs/assigner.html",
-            Context ({'records': records,
-                      'form': regions_form,
-                      'titre': u"Assignation de régions par lots",
-                      'description': u"Sélectionner les regions qui seront associées aux références suivantes :" ,
-                      }),
-                     context_instance = RequestContext(request))
+    return render_to_response(
+        "savoirs/assigner.html",
+        dict(objects=objects,
+             form=regions_form,
+             titre=u"Assignation de régions par lots",
+             description=u"Sélectionner les régions qui seront associées aux références suivantes :"),
+        context_instance = RequestContext(request)
+    )
 
 @login_required
-def assigner_disciplines(request):
+def assigner_disciplines(request, app_name, model_name):
     ids = request.GET.get("ids").split(",")
-    records = Record.objects.in_bulk(ids)
+    model = get_model(app_name, model_name)
+    objects = model.objects.filter(pk__in=ids)
     if request.method == 'POST':
         disciplines_form = DisciplinesForm(request.POST)
 
         if disciplines_form.is_valid():
-
-            # charger tous les objets disciplines
-            disciplines = []
-            for discipline_id in request.POST.getlist("disciplines"):
-                disciplines.append(Discipline.objects.get(id=discipline_id))
-
-            # assigner chaque disciplines à chaque référence
-            for r in records.values():
-                for p in disciplines:
-                    r.disciplines.add(p)
-                r.save()
+            disciplines = disciplines_form.cleaned_data['disciplines']
+            for o in objects:
+                o.assigner_disciplines(disciplines)
+                o.save()
             
             # retouner un status à l'utilisateur sur la liste des références
             disciplines_noms = u", ".join([p.nom for p in disciplines])
-            succes = u"Les disciplines %s ont été assignées à %s références" % (disciplines_noms, len(ids))
+            succes = u"Les disciplines %s ont été assignées à %s objets" % (disciplines_noms, len(ids))
             request.user.message_set.create(message=succes)
-            return HttpResponseRedirect('/admin/savoirs/record')
+            return HttpResponseRedirect(url('admin:%s_%s_changelist' % (app_name, model_name)))
     else:
         disciplines_form = DisciplinesForm()
 
-    return render_to_response ("savoirs/assigner.html",
-            Context ({'records': records,
-                      'form': disciplines_form,
-                      'titre': u"Assignation de disciplines par lots",
-                      'description': u"Sélectionner les disciplines qui seront associées aux références suivantes :" ,
-                      }),
-                     context_instance = RequestContext(request))
+    return render_to_response(
+        "savoirs/assigner.html",
+        dict(objects=objects,
+             form=disciplines_form,
+             titre=u"Assignation de disciplines par lots",
+             description=u"Sélectionner les disciplines qui seront associées aux références suivantes :"),
+        context_instance = RequestContext(request)
+    )
 
 @login_required
 def assigner_thematiques(request):
@@ -170,3 +188,60 @@ def assigner_thematiques(request):
                       'description': u"Sélectionner les thématiques qui seront associées aux références suivantes :" ,
                       }),
                      context_instance = RequestContext(request))
+
+@login_required
+def confirmation(request, action):
+    ids = request.GET.get("ids").split(",")
+    type, action  = action.split('/')[0:2]
+
+    # determination du contexte de validation
+    if action == u'valider':
+        objects = [r for r in Record.objects.in_bulk(ids).values() if r.est_complet()]
+        action = ('validated', True)
+        desc = u'validées'
+        model = u'références'
+
+    elif action == u'invalider':
+        objects = Record.objects.in_bulk(ids).values()
+        action = ('validated', False)
+        desc = u'invalidées'
+        model = u'références'
+    
+    elif action == u'visible':
+        objects = Actualite.objects.in_bulk(ids).values()
+        action = ('visible', True)
+        desc = u'visibles'
+        model = u'actualités'
+    
+    elif action == u'invisible':
+        objects = Actualite.objects.in_bulk(ids).values()
+        action = ('visible', False)
+        desc = u'invisibles'
+        model = u'actualités'
+
+    else:
+       raise Exception("action invalide %s " % action)
+
+    if request.method == 'POST':
+        confirmation_form = ConfirmationForm(request.POST)
+
+        if confirmation_form.is_valid():
+            for o in objects:
+                setattr(o, action[0], action[1])
+                o.save()
+
+            succes = u""u"Les références ont été %s" % desc
+            request.user.message_set.create(message=succes)
+            return HttpResponseRedirect('/admin/savoirs/%s' % type)
+    else:
+        confirmation_form = ConfirmationForm()
+
+
+    return render_to_response ("savoirs/confirmation.html",
+            Context ({'objects': objects,
+                      'action': action,
+                      'form': confirmation_form,
+                      'titre': u"Validation par lots",
+                      'description': u"Les %s suivantes vont être %s:" % (model, desc) ,
+                      }),
+                     context_instance = RequestContext(request))