experiENS/avisstage/views.py

# coding: utf-8

from django.shortcuts import render, redirect, get_object_or_404

from django.views.generic import DetailView, ListView
from django.views.generic.edit import UpdateView, CreateView
from django import forms
from django.urls import reverse
from django.contrib.auth.decorators import login_required
from braces.views import LoginRequiredMixin
from django.http import JsonResponse, HttpResponseForbidden
from django.core.mail import send_mail
from django.db.models import Q

from avisstage.models import Normalien, Stage, Lieu, AvisLieu, AvisStage
from avisstage.forms import StageForm, LieuForm, AvisStageForm, AvisLieuForm, FeedbackForm

# Page d'accueil
def index(request):
    return render(request, 'avisstage/index.html')

# Espace personnel
@login_required
def perso(request):
    return render(request, 'avisstage/perso.html')

# Profil
class ProfilEdit(UpdateView, LoginRequiredMixin):
    model = Normalien
    fields = ['nom', 'promotion', 'mail']
    template_name = 'avisstage/formulaires/profil.html'

    def get_object(self):
        return self.request.user.profil
    
    def get_context_data(self, **kwargs):
        print kwargs
        return super(ProfilEdit, self).get_context_data(**kwargs)

    def get_success_url(self):
        return reverse('avisstage:perso')
    
class ProfilView(DetailView, LoginRequiredMixin):
    model = Normalien
    template_name = 'avisstage/detail/profil.html'
    
    def get_object(self):
        return Normalien.objects.get(user__username=self.kwargs.get('username'))

# Stages
@login_required
def manage_stage(request, pk=None):
    if pk is None:
        stage = Stage(auteur=request.user.profil)
        avis_stage = AvisStage(stage=stage)
        c_del = False
    else:
        stage = Stage.objects.filter(auteur=request.user.profil).get(pk=pk)
        avis_stage, _ = AvisStage.objects.get_or_create(stage=stage)
        c_del = True

    AvisLieuFormSet = forms.inlineformset_factory(
        Stage, AvisLieu, form=AvisLieuForm, can_delete=c_del, extra=0)

    if request.method == "POST":
        form = StageForm(request.POST, request=request, instance=stage, prefix="stage")
        avis_stage_form = AvisStageForm(request.POST,
                                        instance=avis_stage, prefix="avis")
        avis_lieu_formset = AvisLieuFormSet(request.POST, instance=stage,
                                         prefix="lieux")
        if (form.is_valid() and
            avis_stage_form.is_valid() and
            avis_lieu_formset.is_valid()):
            stage = form.save()
            avis_stage_form.instance.stage = stage
            avis_stage_form.save()
            avis_lieu_formset.save()
            return redirect(reverse('avisstage:stage', kwargs={'pk':stage.id}))
    else:
        form = StageForm(instance=stage, prefix="stage")
        avis_stage_form = AvisStageForm(instance=avis_stage, prefix="avis")
        avis_lieu_formset = AvisLieuFormSet(instance=stage, prefix="lieux")

    return render(request, "avisstage/formulaires/stage.html",
                  {'form': form, 'avis_stage_form': avis_stage_form,
                   'avis_lieu_formset': avis_lieu_formset,
                   'creation': pk is None})

class StageView(DetailView, LoginRequiredMixin):
    model = Stage
    template_name = 'avisstage/detail/stage.html'

    def get_queryset(self):
        filtre = Q(auteur__user_id=self.request.user.id) | Q(public=True)
        return Stage.objects.filter(filtre)

class StageListe(ListView, LoginRequiredMixin):
    model = Stage
    template_name = 'avisstage/liste/stage.html'
    
    def get_queryset(self):
        return Stage.objects.filter(public=True).order_by('-date_maj')

    
# Lieux des stages
class LieuAjout(CreateView, LoginRequiredMixin):
    model = Lieu
    form_class = LieuForm
    template_name = 'avisstage/formulaires/lieu.html'

    def form_valid(self, form):
        if self.request.GET.get("format", "") == "json":
            self.object = form.save()
            return JsonResponse({"success": True,
                                 "id": self.object.id})
        else:
            super(LieuAjout, self).form_valid(form)

    def form_invalid(self, form):
        if self.request.GET.get("format", "") == "json":
            return JsonResponse({"success": False,
                                 "errors": form.errors})
        else:
            super(LieuAjout, self).form_valid(form)

@login_required
def publier_stage(request, pk):
    if request.method != "POST":
        return HttpResponseForbidden()
    stage = get_object_or_404(Stage, pk=pk)
    if stage.auteur != request.user.profil:
        return HttpResponseForbidden()
    if "publier" in request.POST:
        stage.public = True
    else:
        stage.public = False
    stage.save()
    return redirect(reverse("avisstage:stage", kwargs={"pk": pk}))

@login_required
def recherche(request):
    return render(request, 'avisstage/recherche.html')


# FEEDBACK
@login_required
def feedback(request):
    if request.method == "POST":
        form = FeedbackForm(request.POST)
        if form.is_valid():
            objet   = form.cleaned_data['objet']
            message = form.cleaned_data['message']
            send_mail(
                "[experiENS] "+ objet,
                message,
                request.user.username + "@clipper.ens.fr",
                ['champeno@clipper.ens.fr'],
                fail_silently=False,
            )
            if request.GET.get("format", None) == "json":
                return JsonResponse({"success": True})
            return redirect(reverse("avisstage:index"))
        else:
            if request.GET.get("format", None) == "json":
                return JsonResponse({"success": False,
                                     "errors": form.errors})
    else:
        form = FeedbackForm()
    return render(request, 'avisstage/formulaire/feedback.html', {"form": form})