Ultron/ultron/core/views.py

from datetime import datetime, timedelta

from django.db.models import Q
from django.shortcuts import render
from django.utils import timezone
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 django.urls import reverse

from ultron.objective.models import Routine
from ultron.profiles.models import Profile
from ultron.followup.models import Skill, Point
from ultron.location.models import Place, Club
from ultron.people.models import Gymnast
from ultron.planning.models import Event
from ultron.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(reverse("home"))

            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(reverse("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(date_begin__gte=timezone.now()).order_by(
        "date_begin"
    )[:10]

    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()

    limit_date = timezone.now() - timedelta(days=14)
    waiting_update_gymnast = Gymnast.objects.exclude(
        Q(is_active=False)
        | Q(mindstate__created_at__gte=limit_date)
        | Q(points__created_at__gte=limit_date)
        | Q(chronos__created_at__gte=limit_date)
        | Q(accident__created_at__gte=limit_date)
        | Q(known_skills__created_at__gte=limit_date)
    ).distinct()

    nb_active_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()
    nb_club = Club.objects.all().count()
    percentage_week = int(
        (get_number_of_weeks_between(datetime(2021, 9, 1), datetime.now()) / 52) * 100
    )

    birthday_list = next_birthdays(request, 10)

    # check if gymnast have point
    # ---------------------------
    # 1. récupérer tous les évènements passés
    # 2. pour chaque event, vérifier que tous les gymnastes renseignés
    #    dans les participants ont des points associés.
    #       S'il n'y a pas de point, faire une alerte à l'utilisateur qui se connecte.

    # Check if gymnast have update
    # -----------------------------
    # lister tous les gymnastes qui n'ont pas eu d'update depuis... 2 semaines ?
    # peut-être le paramètre (en jour) devrait être stocké en DB.
    #       S'il n'y a pas d'update, faire une alerte à l'utilisateur qui se connecte.

    context = {
        "event_list": event_list,
        "last_updated_gymnast": last_updated_gymnast,
        "waiting_update_gymnast": waiting_update_gymnast,
        "nb_active_gymnast": nb_active_gymnast,
        "nb_event": nb_event,
        "nb_skill": nb_skill,
        "nb_routine": nb_routine,
        "nb_score": nb_score,
        "nb_club": nb_club,
        "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)