kpsul/kfet/views.py

from django.shortcuts import render, get_object_or_404
from django.core.exceptions import PermissionDenied
from django.contrib.auth.decorators import login_required, permission_required
from django.contrib.auth.models import User
from django.http import HttpResponse, Http404
import json
from gestioncof.models import CofProfile, Clipper
from kfet.models import Account
from kfet.forms import *

@login_required
def home(request):
    return render(request, "kfet/base.html")

def put_cleaned_data_in_dict(dict, form):
    for field in form.cleaned_data:
        dict[field] = form.cleaned_data[field]

@login_required
@permission_required('account.is_team')
def account(request):
    accounts = Account.objects.all()
    return render(request, "kfet/account.html", { 'accounts' : accounts })

@login_required
@permission_required('account.is_team')
def account_create(request):

    # A envoyer au template
    data_template = {
        'account_trigramme_form': AccountTriForm(),
        'post'      : False,
        'success'   : False,
        'trigramme' : '',
        'errors'    : {},
    }

    # Enregistrement
    if request.method == "POST":
        # Pour indiquer la tentative d'enregistrement au template
        data_template['post'] = True

        # Checking permission
        if not request.user.has_perm('kfet.add_account'):
            raise PermissionDenied

        # Peuplement des forms
        username = request.POST.get('username')
        try:
            user     = User.objects.get(username=username)
            (cof, _) = CofProfile.objects.get_or_create(user=user)
            user_form = UserForm(request.POST, instance=user)
            cof_form  = CofForm(request.POST, instance=cof)
        except User.DoesNotExist:
            user_form = UserForm(request.POST)
            cof_form  = CofForm(request.POST)
        trigramme_form = AccountTriForm(request.POST)
        account_form   = AccountNoTriForm(request.POST)

        # Ajout des erreurs pour le template
        data_template['errors']['user_form'] = user_form.errors
        data_template['errors']['cof_form']  = cof_form.errors
        data_template['errors']['trigramme_form'] = trigramme_form.errors
        data_template['errors']['account_form'] = account_form.errors

        if all((user_form.is_valid(), cof_form.is_valid(),
                trigramme_form.is_valid(), account_form.is_valid())):
            data = {}
            # Fill data for Account.save()
            put_cleaned_data_in_dict(data, user_form)
            put_cleaned_data_in_dict(data, cof_form)

            try:
                account = trigramme_form.save(data = data)
                account_form = AccountNoTriForm(request.POST, instance=account)
                account_form.save()
                data_template['success']   = True
                data_template['trigramme'] = account.trigramme
            except Account.UserHasAccount as e:
                data_template['errors']['global'] = \
                    "Cet utilisateur a déjà un compte K-Fêt : " + e.trigramme
            except PermissionDenied:
                print("perm")

    return render(request, "kfet/account_create.html", data_template)

def account_form_set_readonly_fields(user_form, cof_form):
    user_form.fields['username'].widget.attrs['readonly'] = True
    cof_form.fields['login_clipper'].widget.attrs['readonly'] = True
    cof_form.fields['is_cof'].widget.attrs['disabled'] = True

@login_required
@permission_required('kfet.is_team')
def account_create_ajax(request, username=None, login_clipper=None):
    user = None
    if login_clipper:
        # à partir d'un clipper
        # le user associé à ce clipper ne devrait pas encore existé
        clipper = get_object_or_404(Clipper, username = login_clipper)
        try:
            # Vérification que clipper ne soit pas déjà dans User
            user = User.objects.get(username=login_clipper)
            # Ici, on nous a menti, le user existe déjà
            username = user.username
            login_clipper = None
        except User.DoesNotExist:
            # Clipper (sans user déjà existant)

            # UserForm - Prefill + Création
            user_initial_data = {
                    'username' : login_clipper,
                    'email'    : login_clipper + "@clipper.ens.fr"}
            if clipper.fullname:
                # Prefill du nom et prénom
                names = clipper.fullname.split()
                # Le premier, c'est le prénom
                user_initial_data['first_name'] = names[0]
                if len(names) > 1:
                    # Si d'autres noms -> tous dans le nom de famille
                    user_initial_data['last_name'] = " ".join(names[1:])
            user_form = UserForm(initial = user_initial_data)

            # CofForm - Prefill + Création
            cof_initial_data = { 'login_clipper': login_clipper }
            cof_form = CofForm(initial = cof_initial_data)

            # AccountForm
            account_form = AccountForm()

            # Protection (read-only) des champs username et login_clipper
            account_form_set_readonly_fields(user_form, cof_form)
    if username:
        # le user existe déjà
        user = get_object_or_404(User, username=username)
        # récupération du profil cof
        (cof, _) = CofProfile.objects.get_or_create(user=user)
        # UserForm + CofForm - Création à partir des instances existantes
        user_form = UserForm(instance = user)
        cof_form  = CofForm(instance = cof)
        # AccountForm
        account_form = AccountNoTriForm()
        # Protection (read-only) des champs username et login_clipper
        account_form_set_readonly_fields(user_form, cof_form)
    elif not login_clipper:
        # connaît pas du tout, faut tout remplir
        user_form    = UserForm()
        cof_form     = CofForm()
        account_form = AccountNoTriForm()

    return render(request, "kfet/account_create_form.html", {
            'account_form' : account_form,
            'cof_form'     : cof_form,
            'user_form'    : user_form,
            })

@login_required
@permission_required('kfet.is_team')
def account_is_validandfree_ajax(request):
    if not request.GET.get("trigramme"):
        raise Http404
    trigramme = request.GET.get("trigramme")
    data = Account.is_validandfree(trigramme)
    return HttpResponse(json.dumps(data), content_type = 'application/json')

@login_required
def account_read(request, trigramme):
    try:
        account = Account.objects.get(trigramme=trigramme)
    except Account.DoesNotExist:
        raise Http404

    # Checking permissions
    if not request.user.has_perm('kfet.is_team') \
            and request.user != account.cofprofile.user:
        raise PermissionDenied

    return render(request, "kfet/account_read.html", { 'account' : account })

@login_required
def account_update(request, trigramme):
    try:
        account = Account.objects.get(trigramme=trigramme)
    except Account.DoesNotExist:
        raise Http404

    # Checking permissions
    if not request.user.has_perm('kfet.change_account') \
            and request.user != account.cofprofile.user:
        raise PermissionDenied

    # Pour le template
    post = False
    success = False

    if request.method == "POST":
        # Update attempt
        post = True

        if request.user.has_perm('kfet.change_account'):
            account_form = AccountForm(request.POST, instance = account)
        else:
            account_form = AccountRestrictForm(request.POST, instance = account)
        cof_form  = CofRestrictForm(request.POST, instance=account.cofprofile)
        user_form = UserRestrictForm(request.POST, instance=account.cofprofile.user)

        if all((account_form.is_valid(), cof_form.is_valid(), user_form.is_valid())):
            data = {}
            # Fill data for Account.save()
            put_cleaned_data_in_dict(data, user_form)
            put_cleaned_data_in_dict(data, cof_form)

            # Updating
            account_form.save(data = data)
            success = True
    else:
        # No update attempt
        if request.user.has_perm('kfet.change_account'):
            account_form = AccountForm(instance = account)
        else:
            account_form = AccountRestrictForm(instance = account)
        cof_form  = CofRestrictForm(instance = account.cofprofile)
        user_form = UserRestrictForm(instance = account.cofprofile.user)

    return render(request, "kfet/account_update.html", {
            'account'      : account,
            'account_form' : account_form,
            'cof_form'     : cof_form,
            'user_form'    : user_form,
            'post'         : post,
            'success'      : success,
            })