Ultron/config/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 ultron.objective.models import Routine
from ultron.profiles.models import Profile
from ultron.followup.models import Accident, Skill, MindState, 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("/")
            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)

    # 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,
        "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)