172 lines
5.8 KiB
Python
172 lines
5.8 KiB
Python
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)
|