auf_savoirs_en_partage/savoirs/forms.py

   1 # -*- encoding: utf-8 -*-
   2 import re, datetime
   3 from django import forms
   4 from django import db
   5 from django.db.models import Q
   6 from django.db import models
   7 from django.contrib.admin import widgets
   8 from datamaster_modeles.models import Thematique, Pays, Region
   9 from models import Evenement, Discipline, Record, Actualite
  10 from savoirs.lib.recherche import build_search_regexp
  11 from savoirs.admin import EvenementAdminForm
  12 import settings
  13
  14 # Modifications custom aux champs Django
  15
  16 class SEPDateField(forms.DateField):
  17     """Un champ de date avec des valeurs par défaut un peu modifiées."""
  18
  19     def __init__(self, *args, **kwargs):
  20         super(SEPDateField, self).__init__(self, *args, **kwargs)
  21
  22         # La classe "date" active le datepicker dans sep.js
  23         # Nous recevons les dates en format français
  24         format = '%d/%m/%Y'
  25         self.widget = forms.DateInput(attrs={'class': 'date'}, format=format)
  26         self.input_formats = [format,]
  27
  28 # Formulaires de recherche
  29
  30 class RecordSearchForm(forms.Form):
  31     """Formulaire de recherche pour les ressources."""
  32
  33     class TypeChoices(object):
  34
  35         def __iter__(self):
  36             """Génère dynamiquement les choix possibles pour la recherche par type."""
  37             yield ('', '')
  38             cursor = db.connection.cursor()
  39             cursor.execute("""SELECT DISTINCT TRIM(REPLACE(REPLACE(type, ', PeerReviewed', ''), ', NonPeerReviewed', '')) AS clean_type
  40                               FROM savoirs_record ORDER BY clean_type""")
  41             for result in cursor.fetchall():
  42                 type = result[0]
  43                 if type:
  44                     yield (type, type)
  45     TYPE_CHOICES = TypeChoices()
  46
  47     class PublisherChoices(object):
  48
  49         def __iter__(self):
  50             """Génère dynamiquement les choix possibles pour la recherche par éditeur."""
  51             yield ('', '')
  52             cursor = db.connection.cursor()
  53             cursor.execute("SELECT DISTINCT publisher AS publisher FROM savoirs_record ORDER BY publisher")
  54             for result in cursor.fetchall():
  55                 publisher = result[0]
  56                 if publisher not in ('', '-'):
  57                     yield (publisher, publisher)
  58     PUBLISHER_CHOICES = PublisherChoices()
  59
  60     q = forms.CharField(required=False, label="Mots-clés")
  61     auteur = forms.CharField(required=False, label="Auteur ou contributeur")
  62     titre = forms.CharField(required=False, label="Titre")
  63     sujet = forms.CharField(required=False, label="Sujet")
  64     type = forms.ChoiceField(required=False, label="Type de document", choices=TYPE_CHOICES)
  65     publisher = forms.ChoiceField(required=False, label="Éditeur", choices=PUBLISHER_CHOICES)
  66
  67     def get_query_set(self):
  68         """Retourne l'ensemble des ressources qui correspondent aux valeurs
  69            entrées dans le formulaire."""
  70         records = Record.objects.validated()
  71         if self.is_valid():
  72             query = self.cleaned_data['q']
  73             if query:
  74                 records = records.search(query)
  75             auteur = self.cleaned_data['auteur']
  76             if auteur:
  77                 records = records.search_auteur(auteur)
  78             titre = self.cleaned_data['titre']
  79             if titre:
  80                 records = records.search_titre(titre)
  81             sujet = self.cleaned_data['sujet']
  82             if sujet:
  83                 records = records.search_sujet(sujet)
  84             type = self.cleaned_data['type']
  85             if type:
  86                 records = records.filter(type__icontains=type)
  87             publisher = self.cleaned_data['publisher']
  88             if publisher:
  89                 records = records.filter(publisher=publisher)
  90         return records
  91
  92     def get_search_regexp(self):
  93         """Retourne une expression régulière compilée qui peut servir à
  94            chercher les mot-clés recherchés dans un texte."""
  95         if self.is_valid():
  96             return build_search_regexp(self.cleaned_data['q'])
  97
  98 class ActualiteSearchForm(forms.Form):
  99     """Formulaire de recherche pour les actualités."""
 100
 101     q = forms.CharField(required=False, label="Mots-clés")
 102     date_min = SEPDateField(required=False, label="Depuis le")
 103     date_max = SEPDateField(required=False, label="Jusqu'au")
 104
 105     def get_query_set(self):
 106         """Retourne l'ensemble des actualités qui correspondent aux valeurs
 107            entrées dans le formulaire."""
 108         actualites = Actualite.objects.filter(visible=True)
 109         if self.is_valid():
 110             query = self.cleaned_data['q']
 111             if query:
 112                 actualites = actualites.search(query)
 113             date_min = self.cleaned_data['date_min']
 114             if date_min:
 115                 actualites = actualites.filter(date__gte=date_min)
 116             date_max = self.cleaned_data['date_max']
 117             if date_max:
 118                 actualites = actualites.filter(date__lte=date_max)
 119         return actualites
 120
 121     def get_search_regexp(self):
 122         """Retourne une expression régulière compilée qui peut servir à
 123            chercher les mot-clés recherchés dans un texte."""
 124         if self.is_valid():
 125             return build_search_regexp(self.cleaned_data['q'])
 126
 127 class EvenementSearchForm(forms.Form):
 128     """Formulaire de recherche pour les événements."""
 129
 130     q = forms.CharField(required=False, label="Mots-clés")
 131     titre = forms.CharField(required=False, label="Intitulé")
 132     type = forms.ChoiceField(required=False, choices=(('', 'Tous'),)+Evenement.TYPE_CHOICES)
 133     discipline = forms.ModelChoiceField(queryset=Discipline.objects.all(),
 134                                         required=False, label="Discipline", empty_label="Toutes")
 135     date_min = SEPDateField(required=False, label="Depuis le")
 136     date_max = SEPDateField(required=False, label="Jusqu'au")
 137
 138     def get_query_set(self):
 139         """Retourne l'ensemble des événements qui correspondent aux valeurs
 140            entrées dans le formulaire."""
 141         evenements = Evenement.objects.filter(approuve=True)
 142         if self.is_valid():
 143             query = self.cleaned_data['q']
 144             if query:
 145                 evenements = evenements.search(query)
 146             titre = self.cleaned_data['titre']
 147             if titre:
 148                 evenements = evenements.search_titre(titre)
 149             type = self.cleaned_data['type']
 150             if type:
 151                 evenements = evenements.filter(type=type)
 152             discipline = self.cleaned_data['discipline']
 153             if discipline:
 154                 evenements = evenements.filter(Q(discipline=discipline) | Q(discipline_secondaire=discipline))
 155             date_min = self.cleaned_data['date_min']
 156             if date_min:
 157                 evenements = evenements.filter(debut__gte=date_min)
 158             date_max = self.cleaned_data['date_max']
 159             if date_max:
 160                 evenements = evenements.filter(debut__lte=date_max)
 161         return evenements
 162
 163     def get_search_regexp(self):
 164         """Retourne une expression régulière compilée qui peut servir à
 165            chercher les mot-clés recherchés dans un texte."""
 166         if self.is_valid():
 167             return build_search_regexp(self.cleaned_data['q'])
 168
 169 ###
 170
 171 class FrontEndSplitDateTime(widgets.AdminSplitDateTime):
 172     class Media:
 173         extend=False
 174         js = ("/jsi18n/",
 175               settings.ADMIN_MEDIA_PREFIX + "js/core.js",
 176               settings.ADMIN_MEDIA_PREFIX + "js/calendar.js",
 177               settings.ADMIN_MEDIA_PREFIX + "js/admin/DateTimeShortcuts.js",
 178               'js/calendrier.js', )
 179         css = {'all' : ('css/calendrier.css', )}
 180
 181 class EvenementForm(EvenementAdminForm):
 182     debut = forms.DateTimeField(widget=FrontEndSplitDateTime)
 183     fin = forms.DateTimeField(widget=FrontEndSplitDateTime)
 184
 185     class Meta:
 186         model = Evenement
 187         exclude = ('approuve', 'uid')
 188
 189 # Admin views pour les associations par lots
 190
 191 class PaysForm(forms.Form):
 192     values = [(p.id, p.nom) for p in Pays.objects.all()]
 193     pays = forms.MultipleChoiceField(choices=values)
 194
 195 class RegionsForm(forms.Form):
 196     values = [(r.id, r.nom) for r in Region.objects.all()]
 197     regions = forms.MultipleChoiceField(choices=values)
 198
 199 class ThematiquesForm(forms.Form):
 200     values = [(t.id, t.nom) for t in Thematique.objects.all()]
 201     thematiques = forms.MultipleChoiceField(choices=values)
 202
 203 class DisciplinesForm(forms.Form):
 204     values = [(t.id, t.nom) for t in Discipline.objects.all()]
 205     disciplines = forms.MultipleChoiceField(choices=values)
 206
 207 class ConfirmationForm(forms.Form):
 208     pass
 209