Ultron/Ultron/views.py

from datetime import datetime, timedelta, date
from functools import reduce
import operator

from django.db.models import Q
from django.shortcuts import render
from django.template import RequestContext
from django.utils import timezone
from django.utils.html import format_html
from django.contrib.auth import authenticate, login as auth_login, logout as auth_logout
from django.http import HttpResponseRedirect
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_http_methods
from objective.models import Routine

from profiles.models import Profile
from followup.models import Accident, Skill, MindState, Point
from location.models import Place, Club
from people.models import Gymnast
from planning.models import Event
from tools.models import get_number_of_weeks_between


def login(request):
    """
    Formulaire d'authentifictation.
    """

    if request.method == "POST":
        username = request.POST["login"]
        password = request.POST["password"]

        user = authenticate(username=username, password=password)

        if user is not None:  #  Pq pas "if user:" ??
            if user.is_active:
                auth_login(request, user)
                try:
                    profile = Profile.objects.get(user=user)
                    request.session["profileid"] = profile.id
                    request.session["template"] = profile.template_color
                    request.session["sidebar"] = profile.sidebar_color
                    request.session["is_sidebar_minified"] = profile.is_sidebar_minified
                except Exception:
                    pass
                request.session["clubid"] = request.POST.get("clubid", None)
                return HttpResponseRedirect("/")
            else:
                context = {"message": "Account disabled."}
        else:
            context = {"message": "Wrong login/password."}
    else:
        context = {}

    return render(request, "ultron/login.html", context)


@login_required
@require_http_methods(["GET"])
def logout(request):
    """
    Fonction de déconnexion
    """
    auth_logout(request)
    return HttpResponseRedirect("/login/")


def next_birthdays(request, number_of_birthday):
    """
    Renvoie la liste des `number_of_birthday` prochains anniversaires.
    """
    birthday_list = sorted(
        Gymnast.objects.all(), key=lambda t: t.next_birthday_in_days
    )[:number_of_birthday]
    return birthday_list


@login_required
@require_http_methods(["GET"])
def home(request):
    """
    Génère la page d'accueil du site basée sur la saison (si celle-ci est connue)
    """
    event_list = Event.objects.filter(datebegin__gte=timezone.now()).order_by('datebegin')[:5]

    last_updated_gymnast = Gymnast.objects.filter(
        Q(mindstate__created_at__gt=request.user.last_login) |
        Q(points__created_at__gt=request.user.last_login) |
        Q(chronos__created_at__gt=request.user.last_login) |
        Q(accident__created_at__gt=request.user.last_login) |
        Q(known_skills__created_at__gt=request.user.last_login)
    ).distinct()

    nb_gymnast = Gymnast.objects.filter(is_active=True).count()
    nb_event = Event.objects.all().count()
    nb_skill = Skill.objects.all().count()
    nb_routine = Routine.objects.all().count()
    nb_score = Point.objects.all().count()
    percentage_week = int((get_number_of_weeks_between(datetime(2021, 9, 1), datetime.now()) / 52) * 100)

    birthday_list = next_birthdays(request, 5)

    context = {
        'event_list': event_list,
        'last_updated_gymnast': last_updated_gymnast,
        'nb_gymnast': nb_gymnast,
        'nb_event': nb_event,
        'nb_skill': nb_skill,
        'nb_routine': nb_routine,
        'nb_score': nb_score,
        'percentage_week': percentage_week,
        'birthday_list': birthday_list
    }
    return render(request, "ultron/dashboard/dashboard.html", context)


@login_required
@require_http_methods(["GET"])
def search(request):
    """
    Recherche globale au travers de toutes les applications.
    """
    pattern = request.GET.get("pattern", None)

    if pattern:
        gymnast_list = Gymnast.objects.filter(
            Q(last_name__icontains=pattern) | Q(first_name__icontains=pattern)
        )
        skill_list = Skill.objects.filter(
            Q(long_label__icontains=pattern) | Q(short_label__icontains=pattern)
        )
        event_list = Event.objects.filter(
            Q(name__icontains=pattern) | Q(place__name__icontains=pattern)
        )
        place_list = Place.objects.filter(
            Q(name__icontains=pattern) | Q(city__icontains=pattern)
        )
        club_list = Club.objects.filter(
            Q(name__icontains=pattern) | Q(place__name__icontains=pattern) | Q(place__city__icontains=pattern)
        )

        context = {
            'gymnast_list': gymnast_list,
            'skill_list': skill_list,
            'event_list': event_list,
            'place_list': place_list,
            'club_list': club_list,
            'pattern': pattern
        }
    else:
        context = {}

    return render(request, "ultron/search/results.html", context)