auf_savoirs_en_partage/chercheurs/views.py

   1 # -*- encoding: utf-8 -*-
   2 import re
   3
   4 from auf.django.references.models import Etablissement
   5 from django.conf import settings
   6 from django.contrib.auth import REDIRECT_FIELD_NAME
   7 from django.contrib.auth import login as auth_login
   8 from django.contrib.auth import authenticate
   9 from django.contrib.auth.decorators import login_required
  10 from django.contrib.auth.forms import PasswordChangeForm
  11 from django.contrib.sites.models import RequestSite, Site
  12 from django.core.urlresolvers import reverse as url
  13 from django.core.mail import send_mail
  14 from django.http import HttpResponse, Http404
  15 from django.shortcuts import render, get_object_or_404, redirect
  16 from django.template import Context
  17 from django.template.loader import get_template
  18 from django.utils import simplejson
  19 from django.utils.http import int_to_base36, base36_to_int
  20 from django.views.decorators.cache import never_cache
  21 from django.views.decorators.csrf import csrf_protect
  22
  23 from chercheurs.decorators import chercheur_required
  24 from chercheurs.forms import \
  25         ChercheurSearchForm, SetPasswordForm, ChercheurFormGroup, \
  26         AuthenticationForm, GroupeSearchForm, MessageForm
  27 from chercheurs.models import \
  28         Chercheur, Groupe, Message, AdhesionGroupe, AuthLDAP
  29 from chercheurs.utils import \
  30         get_django_user_for_email, create_ldap_hash, check_ldap_hash
  31 from savoirs.models import PageStatique
  32
  33
  34 def index(request):
  35     """
  36     Répertoire des chercheurs
  37     """
  38     search_form = ChercheurSearchForm(request.GET)
  39     if search_form.is_valid():
  40         search = search_form.save(commit=False)
  41     else:
  42         raise Http404
  43     chercheurs = search.run().select_related('etablissement')
  44     sort = request.GET.get('tri')
  45     if sort is not None and sort.endswith('_desc'):
  46         sort = sort[:-5]
  47         direction = '-'
  48     else:
  49         direction = ''
  50     if sort == 'nom':
  51         chercheurs = chercheurs.order_by_nom(direction)
  52     elif sort == 'etablissement':
  53         chercheurs = chercheurs.order_by_etablissement(direction)
  54     elif sort == 'pays':
  55         chercheurs = chercheurs.order_by_pays(direction)
  56     else:
  57         chercheurs = chercheurs.order_by('-date_modification')
  58
  59     try:
  60         p = PageStatique.objects.get(id='repertoire')
  61         entete = p.contenu
  62     except PageStatique.DoesNotExist:
  63         entete = u'<h1>Répertoire des chercheurs</h1>'
  64
  65     nb_chercheurs = chercheurs.count()
  66
  67     return render(request, "chercheurs/index.html", {
  68         'chercheurs': chercheurs,
  69         'nb_chercheurs': nb_chercheurs,
  70         'search_form': search_form,
  71         'entete': entete
  72     })
  73
  74
  75 def inscription(request):
  76     if request.method == 'POST':
  77         forms = ChercheurFormGroup(request.POST)
  78         if forms.is_valid():
  79             chercheur = forms.save()
  80             id_base36 = int_to_base36(chercheur.id)
  81             token = chercheur.activation_token()
  82             template = get_template('chercheurs/activation_email.txt')
  83             domain = RequestSite(request).domain
  84             message = template.render(Context({
  85                 'chercheur': chercheur,
  86                 'id_base36': id_base36,
  87                 'token': token,
  88                 'domain': domain
  89             }))
  90             send_mail(
  91                 'Votre inscription à Savoirs en partage',
  92                 message, None, [chercheur.courriel]
  93             )
  94             return redirect('chercheurs-inscription-faite')
  95     else:
  96         forms = ChercheurFormGroup()
  97
  98     return render(request, "chercheurs/inscription.html", {
  99         'forms': forms
 100     })
 101
 102
 103 def activation(request, id_base36, token):
 104     """Activation d'un chercheur"""
 105     id = base36_to_int(id_base36)
 106     chercheur = get_object_or_404(Chercheur.all_objects, id=id)
 107     if token == chercheur.activation_token():
 108         validlink = True
 109         if request.method == 'POST':
 110             form = SetPasswordForm(request.POST)
 111             if form.is_valid():
 112                 password = form.cleaned_data['password']
 113                 email = chercheur.courriel
 114                 chercheur.actif = True
 115                 user = get_django_user_for_email(email)
 116                 user.set_password(password)
 117                 user.save()
 118                 chercheur.user = user
 119                 chercheur.save()
 120
 121                 # Auto-login
 122                 auth_login(
 123                     request, authenticate(username=email, password=password)
 124                 )
 125                 return redirect('chercheurs.views.perso')
 126         else:
 127             form = SetPasswordForm()
 128     else:
 129         form = None
 130         validlink = False
 131     return render(request, 'chercheurs/activation.html', {
 132         'form': form,
 133         'validlink': validlink
 134     })
 135
 136
 137 @csrf_protect
 138 @login_required
 139 def password_change(request,
 140                     template_name='registration/password_change_form.html',
 141                     post_change_redirect=None,
 142                     password_change_form=PasswordChangeForm):
 143     if post_change_redirect is None:
 144         post_change_redirect = url(
 145             'django.contrib.auth.views.password_change_done'
 146         )
 147     if request.method == "POST":
 148         form = password_change_form(user=request.user, data=request.POST)
 149         if form.is_valid():
 150             form.save()
 151
 152             # Mot de passe pour LDAP
 153             username = request.user.email
 154             authldap, created = \
 155                     AuthLDAP.objects.get_or_create(username=username)
 156             password = form.cleaned_data.get('new_password1')
 157             authldap.ldap_hash = create_ldap_hash(password)
 158             authldap.save()
 159
 160             return redirect(post_change_redirect)
 161     else:
 162         form = password_change_form(user=request.user)
 163     return render(request, template_name, {'form': form})
 164
 165
 166 @chercheur_required
 167 def desinscription(request):
 168     """Désinscription du chercheur"""
 169     chercheur = request.chercheur
 170     if request.method == 'POST':
 171         if request.POST.get('confirmer'):
 172             chercheur.actif = False
 173             chercheur.save()
 174             request.flash['message'] = \
 175                     "Vous avez été désinscrit du répertoire des chercheurs."
 176             return redirect('django.contrib.auth.views.logout')
 177         else:
 178             request.flash['message'] = "Opération annulée."
 179             return redirect('chercheurs.views.perso')
 180     return render(request, "chercheurs/desinscription.html")
 181
 182
 183 @chercheur_required
 184 @never_cache
 185 def edit(request):
 186     """Edition d'un chercheur"""
 187     chercheur = request.chercheur
 188     if request.method == 'POST':
 189         forms = ChercheurFormGroup(request.POST, chercheur=chercheur)
 190         if forms.is_valid():
 191             forms.save()
 192             request.flash['message'] = "Votre fiche a bien été enregistrée."
 193             return redirect('chercheurs.views.perso')
 194     else:
 195         forms = ChercheurFormGroup(chercheur=chercheur)
 196
 197     return render(request, "chercheurs/edit.html", {
 198         'forms': forms,
 199         'chercheur': chercheur
 200     })
 201
 202
 203 @chercheur_required
 204 def perso(request):
 205     """Espace chercheur (espace personnel du chercheur)"""
 206     chercheur = request.chercheur
 207     modification = request.GET.get('modification')
 208     return render(request, "chercheurs/perso.html", {
 209         'chercheur': chercheur,
 210         'modification': modification
 211     })
 212
 213
 214 def retrieve(request, id):
 215     """Fiche du chercheur"""
 216     chercheur = get_object_or_404(Chercheur, id=id)
 217     return render(request, "chercheurs/retrieve.html", {
 218         'chercheur': chercheur
 219     })
 220
 221
 222 def conversion(request):
 223     return render(request, "chercheurs/conversion.html")
 224
 225
 226 def etablissements_autocomplete(request, pays=None):
 227     term = request.GET.get('term')
 228     if term:
 229         noms = Etablissement.objects.all().filter(membre=True, actif=True)
 230         for word in term.split():
 231             noms = noms.filter(nom__icontains=word)
 232         if pays:
 233             noms = noms.filter(pays=pays)
 234         noms = list(noms.values_list('nom', flat=True)[:20])
 235     else:
 236         noms = []
 237     json = simplejson.dumps(noms)
 238     return HttpResponse(json, mimetype='application/json')
 239
 240
 241 def login(request, template_name='registration/login.html',
 242           redirect_field_name=REDIRECT_FIELD_NAME):
 243     "The Django login view, but using a custom form."
 244     redirect_to = request.REQUEST.get(redirect_field_name, '')
 245
 246     if request.method == "POST":
 247         form = AuthenticationForm(data=request.POST)
 248         if form.is_valid():
 249             # Light security check -- make sure redirect_to isn't garbage.
 250             if not redirect_to or ' ' in redirect_to:
 251                 redirect_to = settings.LOGIN_REDIRECT_URL
 252
 253             # Heavier security check -- redirects to http://example.com
 254             # should not be allowed, but things like
 255             # /view/?param=http://example.com should be allowed. This regex
 256             # checks if there is a '//' *before* a question mark.
 257             elif '//' in redirect_to and re.match(r'[^\?]*//', redirect_to):
 258                     redirect_to = settings.LOGIN_REDIRECT_URL
 259
 260             # Mot de passe pour LDAP
 261             username = form.cleaned_data.get('username')
 262             password = form.cleaned_data.get('password')
 263             authldap, created = \
 264                     AuthLDAP.objects.get_or_create(username=username)
 265             if created or not check_ldap_hash(authldap.ldap_hash, password):
 266                 authldap.ldap_hash = create_ldap_hash(password)
 267                 authldap.save()
 268
 269             # Okay, security checks complete. Log the user in.
 270             auth_login(request, form.get_user())
 271
 272             if request.session.test_cookie_worked():
 273                 request.session.delete_test_cookie()
 274
 275             return redirect(redirect_to)
 276
 277     else:
 278         form = AuthenticationForm(request)
 279     request.session.set_test_cookie()
 280
 281     if Site._meta.installed:
 282         current_site = Site.objects.get_current()
 283     else:
 284         current_site = RequestSite(request)
 285
 286     return render(request, template_name, {
 287         'form': form,
 288         redirect_field_name: redirect_to,
 289         'site': current_site,
 290         'site_name': current_site.name,
 291     })
 292 login = never_cache(login)
 293
 294
 295 # groupes
 296 def groupe_index(request):
 297     search_form = GroupeSearchForm(request.GET)
 298     search = search_form.save(commit=False)
 299     groupes = search.run()
 300     nb_resultats = groupes.count()
 301     try:
 302         p = PageStatique.objects.get(id='groupes')
 303         entete = p.contenu
 304     except PageStatique.DoesNotExist:
 305         entete = '<h1>Liste des groupes</h1>'
 306
 307     est_chercheur, mesgroupes, messages = False, None, None
 308     if request.user.is_authenticated():
 309         try:
 310             chercheur = Chercheur.objects.get(courriel=request.user.email)
 311             mesgroupes = chercheur.groupes.filter(
 312                 membership__statut='accepte', groupe_chercheur=True
 313             )
 314             messages = Message.objects.all().filter(groupe__in=mesgroupes)[:10]
 315             est_chercheur = True
 316         except Chercheur.DoesNotExist:
 317             pass
 318
 319     return render(request, "chercheurs/groupe_index.html", {
 320         'search_form': search_form,
 321         'groupes': groupes.order_by('nom'),
 322         'nb_resultats': nb_resultats,
 323         'entete': entete,
 324         'mesgroupes': mesgroupes,
 325         'messages': messages,
 326         'est_chercheur': est_chercheur,
 327     })
 328
 329
 330 def groupe_adhesion(request, id):
 331     try:
 332         groupe = get_object_or_404(Groupe, id=id)
 333         chercheur = Chercheur.objects.get(courriel=request.user.email)
 334         adhesion, created = AdhesionGroupe.objects.get_or_create(
 335             chercheur=chercheur, groupe=groupe
 336         )
 337         if created:
 338             adhesion.actif = 0
 339             adhesion.save()
 340     except:
 341         pass
 342
 343     return redirect('groupe_retrieve', id=id)
 344
 345
 346 def groupe_retrieve(request, id):
 347     groupe = get_object_or_404(Groupe, id=id)
 348     membres = groupe.membership.all() \
 349             .filter(statut='accepte').order_by('-date_modification')
 350     plus_que_20 = True if membres.count() > 20 else False
 351     membres_20 = membres[:20]
 352     messages = groupe.message_set.all()[:5]
 353
 354     est_chercheur, est_membre, est_membre_actif = False, False, False
 355     if request.user.is_authenticated():
 356         try:
 357             chercheur = Chercheur.objects.get(courriel=request.user.email)
 358             est_chercheur = True
 359             est_membre = chercheur in groupe.membres.all()
 360             est_membre_actif = bool(len(groupe.membership.filter(
 361                 chercheur=chercheur, statut='accepte'
 362             )))
 363         except Chercheur.DoesNotExist:
 364             pass
 365
 366     return render(request, "chercheurs/groupe_retrieve.html", {
 367         'groupe': groupe,
 368         'membres': membres_20,
 369         'plus_que_20': plus_que_20,
 370         'messages': messages,
 371         'est_chercheur': est_chercheur,
 372         'est_membre': est_membre,
 373         'est_membre_actif': est_membre_actif,
 374     })
 375
 376
 377 def groupe_membres(request, id):
 378     groupe = get_object_or_404(Groupe, id=id)
 379     membres = groupe.membership.all() \
 380             .filter(statut='accepte').order_by('chercheur__nom')
 381
 382     return render(request, "chercheurs/groupe_membres.html", {
 383         'groupe': groupe,
 384         'membres': membres,
 385     })
 386
 387
 388 def groupe_messages(request, id):
 389     groupe = get_object_or_404(Groupe, id=id)
 390
 391     est_chercheur, est_membre, est_membre_actif = False, False, False
 392     if request.user.is_authenticated():
 393         try:
 394             chercheur = Chercheur.objects.get(courriel=request.user.email)
 395             est_chercheur = True
 396             est_membre = chercheur in groupe.membres.all()
 397             est_membre_actif = bool(len(groupe.membership.filter(
 398                 chercheur=chercheur, statut='accepte'
 399             )))
 400         except Chercheur.DoesNotExist:
 401             pass
 402
 403     if est_membre_actif and request.method == 'POST':
 404         form = MessageForm(request.POST)
 405         if form.is_valid():
 406             message = form.save(commit=False)
 407             message.groupe = groupe
 408             message.chercheur = chercheur
 409             message.save()
 410
 411             form = MessageForm()
 412
 413     else:
 414         form = MessageForm()
 415
 416     messages = groupe.message_set.all()
 417
 418     return render(request, "chercheurs/groupe_message.html", {
 419         'groupe': groupe,
 420         'messages': messages,
 421         'form': form,
 422         'est_chercheur': est_chercheur,
 423         'est_membre': est_membre,
 424         'est_membre_actif': est_membre_actif,
 425     })