fait en sorte de lier la vue avec avec la page arbitrage, d’afficher autant de .content-arbitrage que de poules ect…{% extends ‘base.html’ %} {% block content %}
<link
rel=“stylesheet”
href=“{{ url_for(‘static’, filename = ‘progress-bar.css’) }}”
/>
<link
rel=“stylesheet”
href=“{{ url_for(‘static’, filename = ‘progress-bar.css’) }}”
/>
<link rel=“stylesheet” href=“{{ url_for(‘static’, filename = ‘arbitrage.css’) }}” />

<div class=“progress-bar”>
<a class=“active-url” href=“{{ url_for(‘ajout_comp_page’)}}”
>Définir une compétition</a
>
<img class=“fleche-bar” src=“…/static/img/fleche.png” alt=“fleche” />
<a
class=“active-url”
>Gestion participants</a
>
<img class=“fleche-bar” src=“…/static/img/fleche.png” alt=“fleche” />
>Créer les poules</a
>
<img class=“fleche-bar” src=“…/static/img/fleche.png” alt=“fleche” />
<img class=“fleche-bar” src=“…/static/img/fleche.png” alt=“fleche” />
>Gestion score</a
>
<img class=“fleche-bar” src=“…/static/img/fleche.png” alt=“fleche” />
>Classement Final</a
>
</div>

<main>
<div class=“classement-provisoire-match”>
<a class=“btn__retour” href=“”><i class=“fa-solid fa-arrow-left”></i> Retour</a>
</div>

<div class=“table__arbitrage”>
<div class=“head__arbitrage”>
<p>Poule n°1 - “nom_piste” - Arbitre : “nom_arbitre”</p>
</div>
<div class=“content__arbitrage”>
<table class=“noms__tireurs”>
<thead>
<tr>
<th>?</th>
<th>?</th>
<th>?</th>
</tr>
</thead>
<tbody>
<tr>
<td>Nom </td>
<td>Prenom </td>
<td>Club </td>
<td>Score </td>
</tr>
<tr>
<td>Nom </td>
<td>Prenom </td>
<td>Club </td>
<td>Score </td>
</tr>
<tr>
<td>Nom </td>
<td>Prenom </td>
<td>Club </td>
<td>Score </td>
</tr>
<tr>
<td>Nom </td>
<td>Prenom </td>
<td>Club </td>
<td>Score </td>
</tr>
</tbody>
</table>
<table class=“score__btn__arbitrer”>
<thead>
<tr>
<th>?</th>
<th>?</th>
<th>?</th>
</tr>
</thead>
<tbody>
<tr>
<td class=“btn__score”><input type=“text”></td>
<td class=“btn__arbitrer”><button>Arbitrer</button></td>
<td class=“btn__score”><input type=“text”></td>
</tr>
<tr>
<td class=“btn__score”><input type=“text”></td>
<td class=“btn__arbitrer”><button>Arbitrer</button></td>
<td class=“btn__score”><input type=“text”></td>
</tr>
<tr>
<td class=“btn__score”><input type=“text”></td>
<td class=“btn__arbitrer”><button>Arbitrer</button></td>
<td class=“btn__score”><input type=“text”></td>
</tr>
<tr>
<td class=“btn__score”><input type=“text”></td>
<td class=“btn__arbitrer”><button>Arbitrer</button></td>
<td class=“btn__score”><input type=“text”></td>
</tr>
</tbody>
</table>
<table class=“noms__tireurs”>
<thead>
<tr>
<th>?</th>
<th>?</th>
<th>?</th>
</tr>
</thead>
<tbody>
<tr>
<td>Nom </td>
<td>Prenom </td>
<td>Club </td>
<td>Score </td>
</tr>
<tr>
<td>Nom </td>
<td>Prenom </td>
<td>Club </td>
<td>Score </td>
</tr>
<tr>
<td>Nom </td>
<td>Prenom </td>
<td>Club </td>
<td>Score </td>
</tr>
<tr>
<td>Nom </td>
<td>Prenom </td>
<td>Club </td>
<td>Score </td>
</tr>
</tbody>
</table>
</div>
<div class=“btn__conclure”>
<button>Conclure</button>
</div>
</div>

</main>
{% endblock %}
import datetime
import random
from .app import app, db, mail
import logging
import math
from .ajout_bd import *
from flask import jsonify, render_template, session, url_for, redirect, request, flash
from .models import *
from flask_wtf import FlaskForm
from wtforms.validators import DataRequired
from wtforms import StringField, PasswordField
from hashlib import sha256
from flask_login import login_user, logout_user, current_user
from flask_mail import Message
import datetime
# from flask import make_response
# from weasyprint import HTML

def send_verification_email(user_email, code):
with app.app_context():
msg = Message(“Votre code de vérification”, recipients=[user_email])
msg.body = f"Votre code de vérification est : {code}“
mail.send(msg)

def send_bienvenue_email(user_email, user_pseudo):
with app.app_context():
msg = Message(“Bienvenue sur COMPETITION ESCRIME”, recipients=[user_email])
msg.body = f"Bonjour {user_pseudo},\n\nBienvenue sur COMPETITION ESCRIME !\n\nNous vous souhaitons une bonne navigation sur notre site.\n\nL’équipe COMPETITION ESCRIME”
mail.send(msg)

logging.basicConfig(filename=‘debug.log’, level=logging.DEBUG)
class LoginForm(FlaskForm):
email_username = StringField(‘email_username’, validators=[DataRequired()])
password = PasswordField(‘password’, validators=[DataRequired()])

def get_authenticated_user(self):
user = User.query.filter_by(emailUser=self.email_username.data).first()
if user is None:
user = User.query.filter_by(pseudoUser=self.email_username.data).first()
if user is None:
return None
m = sha256 ()
m.update(self.password.data.encode ())
passwd = m. hexdigest ()
return user if passwd == user.mdpUser else None

class InscriptionForm(FlaskForm):
pseudo = StringField(‘pseudo’, validators=[DataRequired()])
email = StringField(‘email’, validators=[DataRequired()])
password = PasswordField(‘password’, validators=[DataRequired()])
comfirm_password = PasswordField(‘comfirm_password’, validators=[DataRequired()])

class EditUserForm(FlaskForm):
newpsswd = PasswordField(“Nouveau mot de passe”)
confirm = PasswordField(“Confirmez le nouveau mot de passe”)
username = StringField(“Pseudonyme actuelle”)
password = PasswordField(“Mot de passe actuelle”)

@app.context_processor
def inject_user_status():
if current_user.is_authenticated:
return {“user_status”: current_user.statutUser}
return {“user_status”: None}

@app.route(“/gestions_scores/”)
def gestion_scores():
return render_template(“page-score.html”)

@app.route(“/arbitrage/<int:id_comp>/<int:id_type_match>/”, methods=[“GET”, “POST”])
def arbitrage(id_comp, id_type_match=1):
if request.method == “POST”:
absent = request.form.get(‘liste_absents’, ‘’)
if id_type_match == 1:
poules = {}
nb_poules = get_nb_poules(id_comp)
for i in range(1, nb_poules+1):
poules[i] = {}
tireurs_club = {} # dict avec le tireur en clé et le nom du club en valeur
for tireur in get_liste_tireurs_escrimeurs_poule(id_comp, i):
tireurs_club[tireur] = get_club_tireur_escrimeur(tireur).nomClub
poules[i][‘tireurs’] = tireurs_club
poules[i][‘piste’] = get_piste_poule(id_comp, i)
poules[i][“id_arbitre”] = get_id_arbitre_poule(id_comp, i)
poules[i][“stats”] = get_poule_stats(i)
poules[i][“matchs”] = get_matchs_poules(i, id_comp)
poules[i][‘arbitre’] = get_arbitre_escrimeur_poule(id_comp, i).nomE + " " + get_arbitre_escrimeur_poule(id_comp, i).prenomE
for num_poule in range(1, nb_poules + 1):
matches = get_matchs_poules(num_poule, id_comp)
scores = {}
print(“avant”)
for match in matches:
match_found = get_match(match.numeroLicenceE1, match.numeroLicenceE2, num_poule, id_comp)
if match_found:
scores[(match_found.numeroLicenceE1, match_found.numeroLicenceE2)] = {
‘touchesDonneesTireur1’: match_found.touchesDonneesTireur1,
‘touchesRecuesTireur2’: match_found.touchesRecuesTireur2
}
scores[(match_found.numeroLicenceE2, match_found.numeroLicenceE1)] = {
‘touchesDonneesTireur2’: match_found.touchesDonneesTireur2,
‘touchesRecuesTireur1’: match_found.touchesRecuesTireur1
}
poules[num_poule][‘scores’] = scores
liste_absents = []
numsAbsent = absent.split(‘,’)
print(“Liste absents: “, numsAbsent)
for licence in numsAbsent:
int_licence = int(licence)
tireur = get_tireur_by_licence(int_licence)
liste_absents.append(tireur.to_dict())
print(liste_absents)
liste_absents_dico = []
if liste_absents != []:
for dict_tireur in liste_absents:
tireur = Tireur.query.get(dict_tireur[‘numeroLicenceE’])
if tireur is not None:
tireur.append(tireur)
liste_absents_dico.append(tireur)
return render_template(“arbitrage.html”, poules=poules, id_comp=id_comp, id_type_match=id_type_match, list_absents=liste_absents)


@app.route(”/gestion_score/<int:id_comp>/<int:id_type_match>/”)
def gestion_score(id_comp, id_type_match=1): # par défaut renvoie à la phase des poules il faut vérifier ça
# récuperer les infos des poules dans un dict avec le numéro de poule en clé et la liste des tireurs,le nom de la piste, le nom de l’arbitre en valeur
if request.method == “POST”:
absent = request.form.get(‘liste_absents’, ‘’)
if id_type_match == 1:
poules = {}
nb_poules = get_nb_poules(id_comp)
for i in range(1, nb_poules+1):
poules[i] = {}
tireurs_club = {} # dict avec le tireur en clé et le nom du club en valeur
for tireur in get_liste_tireurs_escrimeurs_poule(id_comp, i):
tireurs_club[tireur] = get_club_tireur_escrimeur(tireur).nomClub
poules[i][‘tireurs’] = tireurs_club
poules[i][‘piste’] = get_piste_poule(id_comp, i)
poules[i][“id_arbitre”] = get_id_arbitre_poule(id_comp, i)
# poules[i][“stats”] = get_poule_stats(i)
poules[i][“matchs”] = get_matchs_poules(i, id_comp)
poules[i][‘arbitre’] = get_arbitre_escrimeur_poule(id_comp, i).nomE + " " + get_arbitre_escrimeur_poule(id_comp, i).prenomE
for num_poule in range(1, nb_poules + 1):
matches = get_matchs_poules(num_poule, id_comp)
scores = {}
print(“avant”)
for match in matches:
match_found = get_match(match.numeroLicenceE1, match.numeroLicenceE2, num_poule, id_comp)
if match_found:
scores[(match_found.numeroLicenceE1, match_found.numeroLicenceE2)] = {
‘touchesDonneesTireur1’: match_found.touchesDonneesTireur1,
‘touchesRecuesTireur2’: match_found.touchesRecuesTireur2
}
scores[(match_found.numeroLicenceE2, match_found.numeroLicenceE1)] = {
‘touchesDonneesTireur2’: match_found.touchesDonneesTireur2,
‘touchesRecuesTireur1’: match_found.touchesRecuesTireur1
}
poules[num_poule][‘scores’] = scores
liste_absents = []
numsAbsent = absent.split(‘,’)
print(“Liste absents: “, numsAbsent)
for licence in numsAbsent:
int_licence = int(licence)
tireur = get_tireur_by_licence(int_licence)
liste_absents.append(tireur.to_dict())
print(liste_absents)
liste_absents_dico = []
if liste_absents != []:
for dict_tireur in liste_absents:
tireur = Tireur.query.get(dict_tireur[‘numeroLicenceE’])
if tireur is not None:
tireur.append(tireur)
liste_absents_dico.append(tireur)

return render_template(‘gestion_score.html’, poules=poules, id_comp=id_comp, id_type_match=1, list_absents=liste_absents)
else:
print(“autre phases”)

@app.route(‘/update_scores’, methods=[‘POST’])
def update_scores():
data = request.get_json()
license = data[‘license’]
opponent_license = data[‘opponentLicense’]
score = data[‘score’]
id_poule = data[‘idPoule’]
id_piste = data[‘idPiste’]
id_comp = data[‘idCompetition’]
id_arbitre = data[‘idArbitre’]
id_type_match = data[‘idTypeMatch’]
print(“license: “, license , “opponent_license: “, opponent_license, “score: “, score, “id_poule: “, id_poule, “id_piste: “, id_piste, “id_comp: “, id_comp, “id_arbitre: “, id_arbitre, “id_type_match: “, id_type_match)
match1 = Match.query.filter_by(numeroLicenceE1=license, numeroLicenceE2=opponent_license).first()
match2 = Match.query.filter_by(numeroLicenceE1=opponent_license, numeroLicenceE2=license).first()
try:
score = int(score)
except ValueError:
return ‘OK’
if match1:
# mettre à jour le match
print(“Mise à jour du match”)
print(“Avant: “, match1.touchesRecuesTireur1, match1.touchesDonneesTireur1, match1.touchesRecuesTireur2, match1.touchesDonneesTireur2)
match1.touchesDonneesTireur1 = score
match1.touchesRecuesTireur2 = score
db.session.commit()
print(“Après: “, match1.touchesRecuesTireur1, match1.touchesDonneesTireur1, match1.touchesRecuesTireur2, match1.touchesDonneesTireur2)
print(“Match mis à jour”)
elif match2:
# mettre à jour le match
print(“Mise à jour du match”)
print(“Avant: “, match2.touchesRecuesTireur1, match2.touchesDonneesTireur1, match2.touchesRecuesTireur2, match2.touchesDonneesTireur2)
match2.touchesDonneesTireur2 = score
match2.touchesRecuesTireur1 = score
db.session.commit()
print(“Après: “, match2.touchesRecuesTireur1, match2.touchesDonneesTireur1, match2.touchesRecuesTireur2, match2.touchesDonneesTireur2)
print(“Match mis à jour”)
else:
# créer le match
print(“Création du match”)
match = Match(type_match=1, piste=id_piste, arbitre=id_arbitre,
tireur1=license, tireur2=opponent_license,
date_match=datetime.date.today(), heure_match=datetime.datetime.now().time().strftime(”%H:%M:%S”),
touches_recues_tireur1=0, touches_donnees_tireur1=score,
touches_recues_tireur2=score, touches_donnees_tireur2=0)
db.session.add(match)
db.session.commit()
print(“Match créé”)

return ‘OK’

@app.route(”/afficher-score-poule/<int:id_comp>/”)
def afficher_score_poule(id_comp):
competition = Competition.query.get_or_404(id_comp)
scores = get_scores_for_competition(id_comp)
return render_template(‘Affichage-score.html’, data=scores, competition=competition)

def get_scores_for_competition(id_comp):
classements = db.session.query(Classement, Escrimeur, Club).join(
Tireur, Classement.numeroLicenceE == Tireur.numeroLicenceE
).join(
Escrimeur, Tireur.numeroLicenceE == Escrimeur.numeroLicenceE
).join(
Club, Tireur.idClub == Club.idClub
).filter(
Classement.idComp == id_comp
).order_by(
Classement.position
).all()

scores = []
for classement, escrimeur, club in classements:
poules = Poule.query.filter_by(idComp=id_comp).subquery()

victoires = db.session.query(Match).join(poules, Match.idPoule == poules.c.idPoule).filter(
db.or_(
db.and_(Match.numeroLicenceE1 == escrimeur.numeroLicenceE,
Match.touchesDonneesTireur1 > Match.touchesRecuesTireur1),
db.and_(Match.numeroLicenceE2 == escrimeur.numeroLicenceE,
Match.touchesDonneesTireur2 > Match.touchesRecuesTireur2)
)
).count()

total_matchs = db.session.query(Match).join(poules, Match.idPoule == poules.c.idPoule).filter(
db.or_(
Match.numeroLicenceE1 == escrimeur.numeroLicenceE,
Match.numeroLicenceE2 == escrimeur.numeroLicenceE
)
).count()
print(victoires, total_matchs)
vm_ratio = (victoires / total_matchs) if total_matchs > 0 else “N/A”
scores.append({
‘Classement’: classement.position,
‘Prenom’: escrimeur.prenomE,
‘Nom’: escrimeur.nomE,
‘VM’: vm_ratio,
‘Club’: club.nomClub
})

return scores

# @app.route(”/telecharger-pdf/<int:id_comp>/”)
# def telecharger_pdf(id_comp):
# scores = get_scores_for_competition(id_comp)
# competition = Competition.query.get_or_404(id_comp)
# rendered = render_template(‘score_table_pdf.html’, data=scores)
# pdf = HTML(string=rendered).write_pdf()
# response = make_response(pdf)
# response.headers[‘Content-Type’] = ‘application/pdf’
# response.headers[‘Content-Disposition’] = f’attachment; filename=tableau_scores_{competition.nomComp}.pdf’
# return response

@app.route(”/arbre-competition”)
def arbre():
return render_template(“arbre.html”)

@app.route(”/inscription-form/”)
def inscription_page():
return render_template(“Inscription.html”, form = InscriptionForm())

@app.route(”/inscription/”, methods=[“GET”, “POST”])
def inscription():
f = InscriptionForm()
if(User.query.filter_by(pseudoUser=f.pseudo.data).first() is not None or User.query.filter_by(emailUser=f.email.data).first() is not None or f.password.data != f.comfirm_password.data):
if(User.query.filter_by(pseudoUser=f.pseudo.data).first() is not None):
flash(“Pseudo déjà utilisé”, “error”)
if(User.query.filter_by(emailUser=f.email.data).first() is not None):
flash(“Email déjà utilisé”, “error”)
if(f.password.data != f.comfirm_password.data):
flash(“Les mots de passe ne correspondent pas”, “error”)
return render_template(“Inscription.html”, form=f)
else:
m = sha256()
m.update(f.password.data.encode())
u = User(pseudoUser=f.pseudo.data , mdpUser=m.hexdigest(), emailUser=f.email.data, statutUser=“Utilisateur”)
db.session.add(u)
db.session.commit()
send_bienvenue_email(f.email.data, f.pseudo.data)
return redirect(url_for(“home”))

@app.route(”/login/”, methods=[“GET”, “POST”])
def login():
f = LoginForm()
user = f.get_authenticated_user()
if user:
login_user(user)
return redirect(url_for(“home_default”))
else:
flash(“Mot de passe incorrect”, “error”)
return render_template(“Login.html”, form=f)

@app.route(”/logout/”)
def logout ():
logout_user ()
return redirect(url_for(“home”))

@app.route(‘/home/’)
def home_default():
return home_def(5)

@app.route(‘/home/<int:items>’, methods=(“GET”,“POST”,))
def home_def(items, opt= None):
total_pages = 0
if request.method == “POST”:
page = int(request.form.get(‘page’, 1))
if ‘next’ in request.form:
page += 1
elif ‘prev’ in request.form:
page -= 1
# récupere les selection du from
session[‘categorie’] = request.form.get(‘categorie’)
session[‘arme’] = request.form.get(‘arme’)
session[‘sexe’] = request.form.get(‘sexe’)
session[‘statut’] = request.form.get(‘statut’)
else:
page = request.args.get(‘page’, 1, type=int)
session[‘categorie’] = request.args.get(‘categorie’, session.get(‘categorie’))
session[‘arme’] = request.args.get(‘arme’, session.get(‘arme’))
session[‘sexe’] = request.args.get(‘sexe’, session.get(‘sexe’))
session[‘statut’] = request.args.get(‘statut’, session.get(‘statut’))
competitions = get_sample()
categories = get_categories()
armes = get_armes()
nb_participants = {comp.idComp: get_nb_participants(comp.idComp) for comp in competitions}
# filtre pour les compet
compet_filtre = filtrer_competitions(competitions, session.get(‘categorie’), session.get(‘arme’), session.get(‘sexe’), session.get(‘statut’))
if len(compet_filtre) !=0:
total_pages = math.ceil(len(compet_filtre) / items)
competitions = compet_filtre[(page - 1) * items:page * items]
else:
competitions = []
return render_template(
“competition.html”,
title=“Compétitions ESCRIME”,
competitions=competitions,
categories=categories,
armes=armes,
nb_participants=nb_participants,
items=items,
selec_arme=session.get(‘arme’),
selec_categorie=session.get(‘categorie’),
selec_sexe=session.get(‘sexe’),
selec_statut=session.get(‘statut’),
page=page,
compet_filtre = compet_filtre,
total_pages=total_pages
)

@app.route(‘/liste-adherent/<int:items>’, methods=[“GET”, “POST”])
def liste_adherents(items):
total_pages = 0
if request.method == “POST”:
page = int(request.form.get(‘page’, 1))
if ‘next’ in request.form:
page += 1
elif ‘prev’ in request.form:
page -= 1
else:
page = request.args.get(‘page’, 1, type=int)
adherents = get_adherents()
categories = get_categories()
role = request.form.get(‘statut’, session.get(‘statuta’, ‘’))
categorie = request.form.get(‘categorie’, session.get(‘categoriea’, ‘’))
sexe = request.form.get(‘sexe’, session.get(‘sexea’, ‘’))

adherents = filtrer_adherent(adherents, categorie, sexe)
if request.method == “POST”:
search_query = request.form.get(‘search’)
# recherche les adhérents en fonction du nom ou prénom
if search_query:
adherents = [adherent for adherent in adherents if search_query.lower() in adherent.Escrimeur.prenomE.lower() or search_query.lower() in adherent.Escrimeur.nomE.lower() or search_query.lower() in str(adherent.Escrimeur.numeroLicenceE)]
session[‘statuta’] = role
session[‘categoriea’] = categorie
session[‘sexea’] = sexe
if len(adherents) !=0:
total_pages = math.ceil(len(adherents) / items)
adherents = adherents[(page - 1) * items:page * items]
else:
adherents = []


return render_template(
“liste-adherents.html”,
title=“Compétitions ESCRIME”,
categories=categories,
selec_categorie=categorie,
selec_sexe=sexe,
selec_statut=role,
adherents=adherents,
items=items,
page=page,
total_pages=total_pages)


@app.route(‘/annuler_comp’, methods=[‘POST’])
def annuler_comp():
# Rediriger vers l’URL d’origine
return redirect(request.referrer or url_for(‘home_default’))

@app.route(”/test_popup/”)
def test_popup():
return render_template(
“test_popup.html”,
title=“Test”)

@app.route(”/edit-user/<name>”, methods=(“GET”,“POST”,))
def edit_user(name):
form = EditUserForm()
if not current_user.is_authenticated:
next = “edit_user”
return redirect(url_for(“login”, next=next))

if form.validate_on_submit():
print(“Formulaire valide”)
user = current_user
if user.pseudoUser != form.username.data:
form.username.errors.append(“Pseudonyme erreur”)
return render_template(“edit-user.html”, form=form, name=name, show_verification_popup=False)

if form.newpsswd.data != form.confirm.data:
form.confirm.errors.append(“Les mots de passe ne correspondent pas”)
return render_template(“edit-user.html”, form=form, name=name, show_verification_popup=False)

code = str(random.randint(1000, 9999))
print(code)
print(user.emailUser)
send_verification_email(user.emailUser, code)
print(“Email envoyé”)
session[‘verification_code’] = code # Stocker le code temporairement
session[‘user_id’] = user.idUser
session[‘new_password’] = form.newpsswd.data # Stocker le nouveau mot de passe temporairement
print(“affichage popup”)
return render_template(“edit-user.html”, form=form, name=name, show_verification_popup=True)

return render_template(“edit-user.html”, form=form, name=name, show_verification_popup=False)

@app.route(”/verify-code/<name>”, methods=[“GET”, “POST”])
def verify_code(name):
if request.method == “POST”:
user_code = request.form[‘code’]
print(user_code)
if user_code == session.get(‘verification_code’):
# Récupérer l’utilisateur et les informations nécessaires
user = User.query.get(session.get(‘user_id’))
if not user:
return “Utilisateur non trouvé”, 404

# Procéder à la mise à jour du mot de passe
new_password = session.get(‘new_password’)
new_password_hash = sha256()
new_password_hash.update(new_password.encode())

user.mdpUser = new_password_hash.hexdigest()
db.session.commit()

# Nettoyer la session
del session[‘verification_code’]
del session[‘user_id’]
del session[‘new_password’]

return redirect(url_for(“home”)) # “Mot de passe mis à jour avec succès!”
else:
flash(“Code de vérification incorrect”, “error”)

return render_template(“edit-user.html”, name=name, form=EditUserForm(), show_verification_popup=True)

@app.route(‘/ajouter_escrimeur/’, methods=[‘GET’, ‘POST’])
def ajouter_escrimeur():
if request.method == ‘POST’:
id = dernier_escrimeur_id() + 1
print(id)

#recup donnees du formulaire
nom = request.form[‘nom_e’]
print(nom)
prenom = request.form[‘prenom_e’]
print(prenom)
date_naissance = request.form[‘date_naissance_e’]
print(date_naissance)
numero_licence = request.form[‘numero_licence_e’]
numero_licence = int(numero_licence)
print(numero_licence)

sexe = ‘Homme’
print(sexe)
num_tel = ‘<PRESIDIO_ANONYMIZED_PHONE_NUMBER>’
num_tel = int(num_tel)
print(num_tel)
default_cat = 1

# creez un nouvel enregistrement d’adherent
nouvel_adherent = Escrimeur(numero_licence_e=numero_licence, categorie=default_cat, prenom_e=prenom, nom_e=nom, date_naissance_e=date_naissance, sexe_e=sexe, num_tel_e=num_tel)
db.session.add(nouvel_adherent)
db.session.commit()
print(“escrimeur ajouté”)
id_club_blois = Club.query.filter_by(nomClub=“BLOIS CE”).first().idClub
print(id_club_blois)
classement_tireur = 0
nouveau_tireur = Tireur(num_licence=numero_licence, club=id_club_blois, classement=classement_tireur)
db.session.add(nouveau_tireur)
db.session.commit()
print(“tireur ajouté”)

return redirect(url_for(‘liste_adherents_def’))

@app.route(‘/’)
def home():
return render_template(‘Login.html’)

from flask import session

@app.route(‘/gestion_poules/<int:id_comp>’, methods=[“GET”, “POST”])
def gestion_poules(id_comp):
liste_poules = []
nb_tireurs = get_nb_tireurs(id_comp)
nb_arbitres = get_nb_arbitres(id_comp)
nb_tireurs_par_poule = nb_tireurs // nb_arbitres
liste_matchs = []
if request.method == “POST”:
classement_checked = ‘classement’ in request.form
club_checked = ‘club’ in request.form
equilibrer_checked = ‘equilibrer’ in request.form
nb_poules = request.form.get(‘nb_poules’)
nb_tireurs_poules_str = request.form.get(‘nb_tireurs/poules’)
if nb_tireurs_poules_str and nb_tireurs_poules_str.isdigit():
nb_tireurs_poules = int(nb_tireurs_poules_str)
liste_tireurs = get_liste_participants_competitions_tireurs(id_comp)
liste_arbitres = get_liste_participants_competitions_arbitres(id_comp)
liste_pistes = get_liste_pistes_selon_nb_arbitres(id_comp, nb_arbitres)
i = len(liste_pistes)
while i < nb_arbitres:
nouvelle_piste = ajouter_piste(id_comp, f"Piste {i+1}”, True)
i += 1
liste_pistes = get_liste_pistes_selon_nb_arbitres(id_comp, nb_arbitres)
nb_tireurs_par_poule = nb_tireurs // nb_arbitres
numero_licence_arbitre = request.form.get(‘numero_licence_arbitre’)
id_arbitre = get_id_arbitre_from_escrimeur(numero_licence_arbitre)
if classement_checked:
liste_tireurs = classer_tireurs(liste_tireurs)
if poules_fabriquables(liste_tireurs, liste_arbitres):
liste_poules = fabriquer_poules(liste_tireurs, liste_arbitres, liste_pistes, “Classement”)
elif club_checked:
if poules_fabriquables(liste_tireurs, liste_arbitres):
liste_poules = fabriquer_poules(liste_tireurs, liste_arbitres, liste_pistes, “Club”)
session[“liste_poules”] = [ [escrimeur[0].numeroLicenceE for escrimeur in poule] for poule in liste_poules]
session[“liste_arbitres”] = [arbitre.numeroLicenceE for arbitre in liste_arbitres]
session[“liste_pistes”] = [piste.idPiste for piste in liste_pistes]
return render_template(‘gestion_poules.html’, id_comp=id_comp, nb_tireurs=get_nb_tireurs(id_comp),
nb_arbitres=get_nb_arbitres(id_comp), liste_tireurs=liste_tireurs, liste_arbitres=liste_arbitres,
liste_poules=liste_poules, nb_tireurs_par_poule=nb_tireurs_par_poule, liste_pistes=liste_pistes)

liste_tireurs = get_liste_participants_competitions_tireurs(id_comp)
liste_arbitres = get_liste_participants_competitions_arbitres(id_comp)
liste_pistes = get_liste_pistes_selon_nb_arbitres(id_comp, nb_arbitres)
competition = Competition.query.get(id_comp)
if competition is not None:
return render_template(‘gestion_poules.html’, id_comp=id_comp, nb_tireurs=nb_tireurs, nb_arbitres=nb_arbitres,
liste_tireurs=liste_tireurs, liste_arbitres=liste_arbitres,
liste_poules=liste_poules, nb_tireurs_par_poule=nb_tireurs_par_poule, liste_pistes=liste_pistes)


@app.route(”/appel/<int:id_comp>”, methods=[“GET”, “POST”])
def appel(id_comp):
rows_data = []
participants_present = []
if request.method == “POST”:
pistes = session.get(“liste_pistes”)
arbitres = session.get(“liste_arbitres”)
liste_poules = session.get(“liste_poules”)
try:
for i in range(len(liste_poules)):
num_licence_arbitre = arbitres[i]
id_arbitre = get_id_arbitre_from_escrimeur(num_licence_arbitre)
nom_poule = f"Poule {i+1}”
id_piste = pistes[i]
ajouter_poule(id_comp, id_piste, id_arbitre, nom_poule)
id_poule = get_id_poule(id_comp, id_piste, id_arbitre, nom_poule)
for j in range(1, len(liste_poules[i])):
ajouter_participant_poule(id_poule, liste_poules[i][j], id_comp)
tireur = Tireur.query.get(liste_poules[i][j])
rows_data.append(tireur.to_dict())
id_type_match = 1 # correspond a un match de poule
date_match = datetime.date.today()
date_match_str = date_match.strftime(“%Y-%m-%d”)
heure_match = datetime.datetime.now().time().strftime(“%H:%M:%S”)

for i in range(len(liste_poules)):
poule = liste_poules[i]
id_piste = pistes[i]
id_arbitre = get_id_arbitre_from_escrimeur(arbitres[i])
id_poule = get_id_poule(id_comp, id_piste, id_arbitre, f"Poule {i+1}“) # Move this line here

for j in range(len(poule)):
for k in range(j+1, len(poule)):
numero_licence_e1 = poule[j]
numero_licence_e2 = poule[k]
match_id = ajouter_match(id_type_match, id_piste, id_arbitre, numero_licence_e1, numero_licence_e2, date_match_str, heure_match, 0, 0, 0, 0)
if match_id is not None:
contenir = Contenir(idPoule=id_poule, idComp=id_comp, idMatch=match_id)
db.session.add(contenir)
db.session.commit()
redirect(url_for(‘appel’, id_comp=id_comp))
competition = Competition.query.get(id_comp)
return render_template(‘appel.html’, competition = competition, rows_data=rows_data, participants_present=participants_present)
except Exception as e:
print(e)
competition = Competition.query.get(id_comp)
if competition is not None:
rows_data = []
participants_comp = get_liste_participants_competitions(id_comp)
participants_comp = get_liste_participants_competitions(id_comp)
for participant in participants_comp:
dict_tireur = participant.tireur.to_dict()
rows_data.append(dict_tireur)
participants_present = []
return render_template(‘appel.html’, competition = competition, rows_data=rows_data, participants_present=participants_present)


@app.route(‘/adherent/’)
def liste_adherents_def():
return liste_adherents(5)


@app.route(”/ajout-comp")
def ajout_comp_page():
armes = get_armes()
categories = get_categories()
lieux = get_lieux()
types = [“Individuelle”, “Equipe”]
return render_template(“ajout-comp.html”, listeArmes=armes, listeCategories=categories, listeTypeMatch=types, lieux=lieux)

@app.route(‘/ajout-comp/’, methods=[‘POST’])
def ajout_comp():
# Récupérez les données du formulaire
nomLieu = request.form.get(‘nomLieu’)
adresseLieu = request.form.get(‘adresseLieu’)
villeLieu = request.form.get(‘villeLieu’)
cpLieu = request.form.get(‘codePostalLieu’)
nomSaison = “Saison 2023” # Supposons que c’est fixe pour cet exemple
nomCat = request.form.get(‘categorie’) # Assurez-vous que le nom correspond au champ dans le HTML
nomArme = request.form.get(‘arme’) # Idem
nomComp = request.form.get(‘titre’)
nomOrga = request.form.get(‘organisateur’)
descComp = f"Competition {nomComp} organisée par {nomOrga}" # Ajoutez un champ pour la description si nécessaire
dateComp = request.form.get(‘date-deroulement’)
heureComp = request.form.get(‘appt’)
sexeComp = request.form.get(‘sexe’)[:1].upper()
estIndividuelle = request.form.get(‘type’) == ‘Individuelle’
print(nomLieu,adresseLieu,villeLieu,cpLieu, nomSaison, nomCat, nomArme, nomComp, nomOrga, descComp, dateComp, heureComp, sexeComp, estIndividuelle)

resultat = creer_competition(nomLieu,adresseLieu,villeLieu,cpLieu, nomSaison, nomCat, nomArme, nomComp, descComp, dateComp, heureComp, sexeComp, estIndividuelle)
if isinstance(resultat, Competition):
return redirect(url_for(‘gestion_participants’, id_comp=resultat.idComp))
else:
return redirect(url_for(‘ajout_comp_page’))

# @app.route(‘/annuler_comp’, methods=[‘POST’])
# def annuler_comp():
# if lieu is None:
# lieu = Lieu(nom_lieu=form.lieu.data, ville_lieu=“”, code_postal_lieu=0, adresse_lieu=“”)
# db.session.add(lieu)
# db.session.commit()
# competition = Competition(idLieu=lieu.idLieu,
# idSaison=Saison.query.get(1).idSaison,
# idCat=getattr(Categorie.query.filter_by(nomCategorie=form.categorie.data).first(), ‘idCat’, None),
# idArme=getattr(Arme.query.filter_by(nomArme=form.arme.data).first(), ‘idArme’, None),
# nomComp=form.titre.data,
# descComp=f"Competition organisée par {form.organisateur.data}“,
# dateComp=form.date_deroulement.data,
# heureComp=form.heure_debut.data,
# sexeComp=form.sexe.data[:1],
# estIndividuelle=form.type_comp.data == ‘individuel’)
# db.session.add(competition)
# db.session.commit()
# flash(‘La compétition a été ajoutée’) # à changer avec une popup
# return redirect(url_for(‘home’))

# # Rediriger vers l’URL d’origine
# return redirect(request.referrer or url_for(‘home_default’))

@app.route(”/gestion_participants/<int:id_comp>“, methods=(“GET”, “POST”))
def gestion_participants(id_comp):
competition = Competition.query.get(id_comp)
participants_blois = get_participants(id_comp, club=“BLOIS CE”)
participants_other = get_participants(id_comp, club=”!“)
participants_arb = get_arbitres(id_comp)
nb_participants_blois = len(participants_blois)
nb_participants_other = len(participants_other)
nb_participants_arb = len(participants_arb)

return render_template(
“gestion-participants.html”,
title=“Gestion des participants”,
participants_blois=participants_blois,
nb_participants_blois=nb_participants_blois,
participants_other=participants_other,
nb_participants_other=nb_participants_other,
competition=competition,
participants_arb=participants_arb,
nb_participants_arb=nb_participants_arb
)

@app.route(‘/ajouter_arbitre_competition/<int:id_comp>’, methods=[‘POST’])
def ajouter_arbitre_competition(id_comp):
data = request.get_json()
numeroLicenceE = data.get(‘numeroLicenceE’)
logging.debug(numeroLicenceE)
arbitre = Arbitre(numeroLicenceE)
db.session.add(arbitre)
participant = ParticipantsCompetition(numeroLicenceE, id_comp)
db.session.add(participant)

db.session.commit()
logging.debug(“ça passe commit participant compet”)

return jsonify({‘success’: True, ‘message’: ‘Arbitre ajouté avec succès’})

@app.route(‘/get_escrimeurs/<gender>/<int:id_comp>’)
def get_escrimeurs_json(gender, id_comp):
escrimeurs_to_display = []
escrimeurs = None
if gender == ‘M’:
escrimeurs = Escrimeur.query.all()
elif gender == “H”:
gender = “Homme”
escrimeurs = Escrimeur.query.filter_by(sexeE=gender).all()
elif gender == “F”:
gender = “Femme”
escrimeurs = Escrimeur.query.filter_by(sexeE=gender).all()

registered_licence_numbers = set()
participants = get_liste_participants_competitions(id_comp)
for participant in participants:
registered_licence_numbers.add(participant.tireur.numeroLicenceE)
escrimeurs_to_display = [e for e in escrimeurs if e.numeroLicenceE not in registered_licence_numbers]
return jsonify([escrimeur.to_dict() for escrimeur in escrimeurs_to_display])

@app.route(‘/get_adherents/<gender>/<int:id_comp>’)
def get_adherents_json(gender,id_comp):
registered_licence_numbers = set()
participants = get_liste_participants_competitions(id_comp)
escrimeurs = get_adherents_adapte_json(gender)
for participant in participants:
registered_licence_numbers.add(participant.tireur.numeroLicenceE)
escrimeurs_to_display = [e for e in escrimeurs if e.numeroLicenceE not in registered_licence_numbers]
return jsonify([escrimeur.to_dict() for escrimeur in escrimeurs_to_display])


@app.route(‘/delete_participant/<int:id_comp>/<int:id>/’, methods=[‘POST’])
def delete_participant(id, id_comp):
participant = ParticipantsCompetition.query.filter_by(numeroLicenceE=id).first()

if participant:
db.session.delete(participant)
db.session.commit()
return redirect(url_for(‘gestion_participants’, id_comp=id_comp))

@app.route(‘/ajouter_escrimeur_competition/<int:id_comp>/’, methods=[‘POST’])
def add_participant(id_comp):
if request.method == ‘POST’:
tireur = request.get_json().get(‘numeroLicenceE’)
logging.debug(f’numerolicence_tireur: {tireur}‘)

tireur = Tireur.query.get(tireur)

logging.debug(f’tireur: {tireur}’)

competition = Competition.query.get(id_comp)
logging.debug(f’competition: {competition}‘)
getattr(competition, “idComp”, None)
if tireur and competition:
participant = ParticipantsCompetition(numeroLicenceE=getattr(tireur, “numeroLicenceE”, None), idComp=getattr(competition, “idComp”, None))
logging.debug(‘creation participant’)
db.session.add(participant)
logging.debug(‘crash ?’)
try:
db.session.commit()
logging.debug(‘Commit successful’)
except Exception as e:
db.session.rollback()
logging.error(f’Error during commit: {str(e)}’)
logging.debug(‘Participant added successfully’)
else:
logging.debug(‘Failed to add participant’)
return redirect(url_for(‘gestion_participants’, id_comp=id_comp))

@app.route(”/delete_arbitre/<int:id_comp>/<int:id_arbitre>/“, methods=[“POST”])
def delete_arbitre(id_comp, id_arbitre):
arbitre = Arbitre.query.filter_by(idArbitre=id_arbitre).first()
if arbitre:
participant = ParticipantsCompetition.query.filter_by(
numeroLicenceE=arbitre.numeroLicenceE, idComp=id_comp
).first()
if participant:
db.session.delete(participant)

db.session.delete(arbitre)
db.session.commit()
return redirect(url_for(“gestion_participants”, id_comp=id_comp))

@app.route(‘/update_database’, methods=[‘POST’])
def update_database():
data = request.get_json()
field = data.get(‘field’)
value = data.get(‘value’)
competition_id = data.get(‘competitionId’)
competition = Competition.query.get(competition_id)
setattr(competition, field, value)
db.session.commit()
return ‘OK’

@app.route(‘/competition/<int:id_comp>’)
def actu_stat_comp(id_comp):
competition = Competition.query.get_or_404(id_comp)
state = get_competition_statut(competition)
if state == ‘participants’:
return redirect(url_for(‘gestion_participants’, id_comp=id_comp))
elif state == ‘poule’:
return redirect(url_for(‘gestion_poules’, id_comp=id_comp))
elif state == ‘appel’:
return redirect(url_for(‘appel’, id_comp=id_comp))
elif state == ‘score’:
return redirect(url_for(‘gestion_score’, id_comp=id_comp))
else:
return “les problèmes”

@app.route(‘/arbre/<int:id_comp>’)
def classement_provisioire(id_comp):
#
#else :
competition = Competition.query.get_or_404(id_comp)
poules = Poule.query.filter_by(idComp=id_comp).all()
quarts = []
demis = []
finale = []
troisieme =[]
for poule in poules:
matchs = Match.query.filter_by(idPoule=poule.idPoule).all()
for match in matchs:
if match.idTypeMatch == 2 :
quarts.append(match.to_dict())
elif match.idTypeMatch == 3 :
demis.append(match.to_dict())
elif match.idTypeMatch == 4 :
finale.append(match.to_dict())
elif match.idTypeMatch == 5 :
troisieme.append(match.to_dict())
return render_template(‘arbre.html’, competition=competition, quarts=quarts, demis=demis, finale=finale, troisieme = troisieme)

@app.route(‘/update_absents’, methods=[‘POST’])
def update_absents():
participants_absents = request.json[‘participants_absents’]
session[‘participants_absents’] = participants_absents
return jsonify(success=True)import datetime

from sqlalchemy import and_, func
from .app import db, login_manager
from flask_login import UserMixin
from sqlalchemy import or_

# Modèle pour représenter le lieu
class Lieu(db.Model):
tablename = ‘LIEU’
idLieu = db.Column(db.Integer, primary_key=True, autoincrement=True)
nomLieu = db.Column(db.String(50), nullable=False)
villeLieu = db.Column(db.String(50), nullable=False)
codePostalLieu = db.Column(db.Integer, nullable=False)
adresseLieu = db.Column(db.String(50), nullable=False)

def init(self, nom_lieu, ville_lieu, code_postal_lieu, adresse_lieu):
self.nomLieu = nom_lieu
self.villeLieu = ville_lieu
self.codePostalLieu = code_postal_lieu
self.adresseLieu = adresse_lieu

# Modèle pour représenter l’arme
class Arme(db.Model):
tablename = ‘ARME’
idArme = db.Column(db.Integer, primary_key=True, autoincrement=True)
nomArme = db.Column(db.String(50), nullable=False, unique = True)

def init(self, nom_arme):
self.nomArme = nom_arme

# Modèle pour représenter la saison
class Saison(db.Model):
tablename = ‘SAISON’
idSaison = db.Column(db.Integer, primary_key=True, autoincrement=True)
nomSaison = db.Column(db.String(50), nullable=False)
dateDebutSaison = db.Column(db.Date, nullable=False)
dateFinSaison = db.Column(db.Date, nullable=False)

def init(self, nom_saison, date_debut_saison, date_fin_saison):
self.nomSaison = nom_saison
self.dateDebutSaison = date_debut_saison
self.dateFinSaison = date_fin_saison

# Modèle pour représenter la catégorie
class Categorie(db.Model):
tablename = ‘CATEGORIE’
idCat = db.Column(db.Integer, primary_key=True, autoincrement=True)
nomCategorie = db.Column(db.String(50), nullable=False, unique=True)

def init(self, nom_categorie):
self.nomCategorie = nom_categorie

# Modèle pour représenter le club
class Club(db.Model):
tablename = ‘CLUB’
idClub = db.Column(db.Integer, primary_key=True, autoincrement=True)
nomClub = db.Column(db.String(50), nullable=False, unique = True)
regionClub = db.Column(db.String(50), nullable=False)

def init(self, nom_club, region_club):
self.nomClub = nom_club
self.regionClub = region_club

# Modèle pour représenter la compétition
class Competition(db.Model):
tablename = ‘COMPETITION’
idComp = db.Column(db.Integer, primary_key=True, autoincrement=True)
idLieu = db.Column(db.Integer, db.ForeignKey(‘LIEU.idLieu’), nullable=False)
lieu = db.relationship(‘Lieu’, backref=‘Lieu.idLieu’)
idSaison = db.Column(db.Integer, db.ForeignKey(‘SAISON.idSaison’), nullable=False)
saison = db.relationship(‘Saison’, backref=‘Saison.idSaison’)
idCat = db.Column(db.Integer, db.ForeignKey(‘CATEGORIE.idCat’), nullable=False)
categorie = db.relationship(‘Categorie’, backref=‘Categorie.idCat’)
idArme = db.Column(db.Integer, db.ForeignKey(‘ARME.idArme’), nullable=False)
arme = db.relationship(‘Arme’, backref=‘Arme.idArme’)
nomComp = db.Column(db.String(50), nullable=False)
descComp = db.Column(db.String(50), nullable=False)
dateComp = db.Column(db.Date, nullable=False)
heureComp = db.Column(db.Time, nullable=False)
sexeComp = db.Column(db.String(1), nullable=False)
estIndividuelle = db.Column(db.Boolean, nullable=False)

def init(self, idLieu, idSaison, idCat, idArme, nomComp, descComp, dateComp, heureComp, sexeComp, estIndividuelle):
self.idLieu = idLieu
self.idSaison = idSaison
self.idCat = idCat
self.idArme = idArme
self.nomComp = nomComp
self.descComp = descComp
self.dateComp = dateComp
self.heureComp = heureComp
self.sexeComp = sexeComp
self.estIndividuelle = estIndividuelle

# Modèle pour représenter la piste
class Piste(db.Model):
tablename = ‘PISTE’
idPiste = db.Column(db.Integer, primary_key=True, autoincrement=True)
idComp = db.Column(db.Integer, db.ForeignKey(‘COMPETITION.idComp’), nullable=False)
nomPiste = db.Column(db.String(50), nullable=False)
estDispo = db.Column(db.Boolean, nullable=False)

competition = db.relationship(‘Competition’, backref=‘Competition.idComp’)

def init(self, competition, nom_piste, est_dispo):
self.idComp = competition
self.nomPiste = nom_piste
self.estDispo = est_dispo

# Modèle pour représenter le type de match
class TypeMatch(db.Model):
tablename = ‘TYPE_MATCH’
idTypeMatch = db.Column(db.Integer, primary_key=True, autoincrement=True)
nomTypeMatch = db.Column(db.String(50), nullable=False)
nbTouches = db.Column(db.Integer, nullable=False)

def init(self, nom_type_match, nb_touches):
self.nomTypeMatch = nom_type_match
self.nbTouches = nb_touches

# Modèle pour représenter l’escrimeur
class Escrimeur(db.Model):
tablename = ‘ESCRIMEUR’
numeroLicenceE = db.Column(db.Integer, nullable=False, primary_key=True)
idCat = db.Column(db.Integer, db.ForeignKey(‘CATEGORIE.idCat’), nullable=False)
prenomE = db.Column(db.String(50), nullable=False)
nomE = db.Column(db.String(50), nullable=False)
dateNaissanceE = db.Column(db.Date, nullable=False)
sexeE = db.Column(db.String(50), nullable=False)
numTelE = db.Column(db.Integer, nullable=True)

categorie = db.relationship(‘Categorie’, backref=‘categorie’)

def init(self, categorie, prenom_e, nom_e, date_naissance_e, numero_licence_e, sexe_e, num_tel_e):
self.idCat = categorie
self.numeroLicenceE = numero_licence_e
self.idCat = categorie
self.prenomE = prenom_e
self.nomE = nom_e
self.dateNaissanceE = date_naissance_e
self.sexeE = sexe_e
self.numTelE = num_tel_e

def to_dict(self):
return {
‘idCat’: self.idCat,
‘prenomE’: self.prenomE,
‘nomE’: self.nomE,
‘dateNaissanceE’: self.dateNaissanceE.isoformat() if self.dateNaissanceE else None,
‘numeroLicenceE’: self.numeroLicenceE,
‘sexeE’: self.sexeE,
‘numTelE’: self.numTelE,
‘categorie’: self.categorie.nomCategorie
}


# Modèle pour représenter les tireurs
class Tireur(db.Model):
tablename = ‘TIREUR’
numeroLicenceE = db.Column(db.Integer, db.ForeignKey(‘ESCRIMEUR.numeroLicenceE’), primary_key=True)
idClub = db.Column(db.Integer, db.ForeignKey(‘CLUB.idClub’), nullable=False)
classement = db.Column(db.Integer, nullable=False)

club = db.relationship(‘Club’, backref=‘Club.idClub’)
escrimeur = db.relationship(‘Escrimeur’, backref=‘Escrimeur.tireur’)

def init(self, num_licence, club, classement):
self.numeroLicenceE = num_licence
self.idClub = club
self.classement = classement

def to_dict(self):
dic_tireur = self.escrimeur.to_dict()
dic_tireur[‘idClub’] = self.idClub
dic_tireur[‘nomClub’] = self.club.nomClub
dic_tireur[‘classement’] = self.classement
return dic_tireur

# Modèle pour représenter les arbitres
class Arbitre(db.Model):
tablename = ‘ARBITRE’
idArbitre = db.Column(db.Integer, primary_key=True, autoincrement=True)
numeroLicenceE = db.Column(db.Integer, db.ForeignKey(‘ESCRIMEUR.numeroLicenceE’))

arbitre = db.relationship(‘Escrimeur’, backref=‘Arbitre.numeroLicenceE’)

def init(self, numeroLicenceE):
self.numeroLicenceE = numeroLicenceE


# Modèle pour représenter les participants aux compétitions
class ParticipantsCompetition(db.Model):
tablename = ‘PARTICIPANTS_COMPETITION’
numeroLicenceE = db.Column(db.Integer, db.ForeignKey(‘ESCRIMEUR.numeroLicenceE’), primary_key=True)
idComp = db.Column(db.Integer, db.ForeignKey(‘COMPETITION.idComp’), primary_key=True)

tireur = db.relationship(‘Escrimeur’, backref=‘PartEscrimeur’, foreign_keys=[numeroLicenceE])
competition = db.relationship(‘Competition’, backref=‘PartCompetition.idComp’)

def init(self, numeroLicenceE, idComp):
self.numeroLicenceE = numeroLicenceE
self.idComp = idComp


# Modèle pour représenter la relation entre les escrimeurs et les armes qu’ils pratiquent
class PratiquerArme(db.Model):
tablename = ‘PRATIQUER_ARME’
numero_licence_e_fk = db.Column(db.Integer, db.ForeignKey(‘ESCRIMEUR.numeroLicenceE’), primary_key=True)
id_arme_fk = db.Column(db.Integer, db.ForeignKey(‘ARME.idArme’), primary_key=True)

escrimeur = db.relationship(‘Escrimeur’, backref=‘armes_pratiquees’)
arme = db.relationship(‘Arme’, backref=‘pratiquee_par’)

def init(self, numero_licence_e_fk, id_arme_fk):
self.numero_licence_e_fk = numero_licence_e_fk
self.id_arme_fk = id_arme_fk

# Modèle pour représenter le classement final
class Classement(db.Model):
tablename = ‘CLASSEMENT’
idComp = db.Column(db.Integer, db.ForeignKey(‘COMPETITION.idComp’), primary_key=True, nullable=False)
numeroLicenceE = db.Column(db.Integer, db.ForeignKey(‘TIREUR.numeroLicenceE’), primary_key=True, nullable=False)
position = db.Column(db.Integer, nullable=False)
competition = db.relationship(‘Competition’, backref=‘competition’)
tireur = db.relationship(‘Tireur’, backref=‘Tireur.numeroLicenceE’)


def init(self, comp, tireur, position):
self.idComp = comp
self.numeroLicenceE = tireur
self.position = position

# Modèle pour représenter les poules
class Poule(db.Model):
tablename = ‘POULE’
idPoule = db.Column(db.Integer, primary_key=True)
idComp = db.Column(db.Integer, db.ForeignKey(‘COMPETITION.idComp’), primary_key=True, nullable=False)
idPiste = db.Column(db.Integer, db.ForeignKey(‘PISTE.idPiste’), nullable=False)
idArbitre = db.Column(db.Integer, db.ForeignKey(‘ARBITRE.idArbitre’), nullable=False)
nomPoule = db.Column(db.String(50), nullable=False)

competition = db.relationship(‘Competition’, backref=‘poules’)
piste = db.relationship(‘Piste’, backref=‘Piste.idPiste’)
arbitre = db.relationship(‘Arbitre’, backref=‘Arbitre.idArbitre’)

def init(self, competition, piste, arbitre, nom_poule):
self.idComp = competition
self.idPiste = piste
self.idArbitre = arbitre
self.nomPoule = nom_poule
self.idPoule = self.get_next_idPoule(competition)

@staticmethod
def get_next_idPoule(competition):
last_poule = Poule.query.filter_by(idComp=competition).order_by(Poule.idPoule.desc()).first()
return 1 if not last_poule else last_poule.idPoule + 1

# Modèle pour représenter les participants aux poules
class ParticipantsPoule(db.Model):
tablename = ‘PARTICIPANTS_POULE’
idPoule = db.Column(db.Integer, db.ForeignKey(‘POULE.idPoule’), primary_key=True)
idComp = db.Column(db.Integer, db.ForeignKey(‘COMPETITION.idComp’), primary_key=True, nullable=False)
numeroLicenceE = db.Column(db.Integer, db.ForeignKey(‘TIREUR.numeroLicenceE’), primary_key=True)

poule = db.relationship(‘Poule’, backref=‘Poule.idPoule’)
tireur = db.relationship(‘Tireur’, backref=‘poule_participants’)

def init(self, poule, tireur, idComp):
self.idPoule = poule
self.numeroLicenceE = tireur
self.idComp = idComp

# Modèle pour représenter les matchs de poule
class Match(db.Model):
tablename = ‘MATCH’
idMatch = db.Column(db.Integer, primary_key=True, autoincrement=True)
idTypeMatch = db.Column(db.Integer, db.ForeignKey(‘TYPE_MATCH.idTypeMatch’), nullable=False)
gagnant = db.Column(db.Integer, db.ForeignKey(‘TIREUR.numeroLicenceE’), nullable=True)
idPiste = db.Column(db.Integer, db.ForeignKey(‘PISTE.idPiste’), nullable=False)
idArbitre = db.Column(db.Integer, db.ForeignKey(‘ARBITRE.idArbitre’), nullable=False)
numeroLicenceE1 = db.Column(db.Integer, db.ForeignKey(‘TIREUR.numeroLicenceE’), nullable=False)
numeroLicenceE2 = db.Column(db.Integer, db.ForeignKey(‘TIREUR.numeroLicenceE’), nullable=False)
dateMatch = db.Column(db.Date, nullable=False)
heureMatch = db.Column(db.Time, nullable=False)
touchesRecuesTireur1 = db.Column(db.Integer)
touchesDonneesTireur1 = db.Column(db.Integer)
touchesRecuesTireur2 = db.Column(db.Integer)
touchesDonneesTireur2 = db.Column(db.Integer)

type_match = db.relationship(‘TypeMatch’, backref=‘TypeMatch.idTypeMatch’)
piste = db.relationship(‘Piste’, backref=‘matches’)
arbitre = db.relationship(‘Arbitre’, backref=‘matches’)
tireur1 = db.relationship(‘Tireur’, foreign_keys=[numeroLicenceE1], backref=‘Tireur.numeroLicenceE1’)
tireur2 = db.relationship(‘Tireur’, foreign_keys=[numeroLicenceE2], backref=‘Tireur.numeroLicenceE2’)

def init(self, type_match, piste, arbitre, tireur1, tireur2, date_match, heure_match, touches_recues_tireur1, touches_donnees_tireur1, touches_recues_tireur2, touches_donnees_tireur2):
self.idTypeMatch = type_match
self.idPiste = piste
self.idArbitre = arbitre
self.numeroLicenceE1 = tireur1
self.numeroLicenceE2 = tireur2
self.dateMatch = date_match
self.heureMatch = heure_match
self.touchesRecuesTireur1 = touches_recues_tireur1
self.touchesDonneesTireur1 = touches_donnees_tireur1
self.touchesRecuesTireur2 = touches_recues_tireur2
self.touchesDonneesTireur2 = touches_donnees_tireur2
self.idPoule = 1

def to_dict(self):
return {
‘idTypeMatch’: self.idTypeMatch,
‘idPiste’: self.idPiste,
‘idArbitre’: self.idArbitre,
‘idPoule’: self.idPoule,
‘tireur1’: Tireur.query.filter_by(numeroLicenceE = self.numeroLicenceE1).first(),
‘tireur2’: Tireur.query.filter_by(numeroLicenceE = self.numeroLicenceE2).first(),
‘dateMatch’: self.dateMatch.isoformat() if self.dateMatch else None,
‘heureMatch’: self.heureMatch.isoformat() if self.heureMatch else None,
‘touchesRecuesTireur1’: self.touchesRecuesTireur1,
‘touchesDonneesTireur1’: self.touchesDonneesTireur1,
‘touchesRecuesTireur2’: self.touchesRecuesTireur2,
‘touchesDonneesTireur2’: self.touchesDonneesTireur2
}


class Contenir(db.Model):
tablename = ‘CONTENIR’
idPoule = db.Column(db.Integer, db.ForeignKey(‘POULE.idPoule’), primary_key=True)
idMatch = db.Column(db.Integer, db.ForeignKey(‘MATCH.idMatch’), primary_key=True)
idComp = db.Column(db.Integer, db.ForeignKey(‘COMPETITION.idComp’), primary_key=True)

def init(self, poule, match, idComp):
self.idPoule = poule
self.idMatch = match
self.idComp = idComp

class User(db.Model, UserMixin):
tablename = ‘USER’
idUser = db.Column(db.Integer, primary_key=True)
pseudoUser = db.Column(db.String (50), unique=True, nullable=False)
mdpUser = db.Column(db.String (64), nullable=False)
emailUser = db.Column(db.String (50), unique=True)
statutUser = db.Column(db.String(50), nullable=False)
def get_id(self):
return self.idUser

@login_manager.user_loader
def load_user(username):
return User.query.get(username)

def get_sample():
return Competition.query.order_by(Competition.dateComp.desc()).all()

def get_competition_by_id(id_comp):
return Competition.query.filter_by(idComp=id_comp).first()

def get_categories():
categories = Categorie.query.all()
return [categorie.nomCategorie for categorie in categories]


def get_saisons():
saisons = Saison.query.all()
return [saison.nomSaison for saison in saisons]

def get_lieux():
lieux = Lieu.query.all()
return [lieu.nomLieu for lieu in lieux]

def get_armes():
armes = Arme.query.all()
return [arme.nomArme for arme in armes]

def get_type_match():
type_match = TypeMatch.query.all()
return [type_match.nomTypeMatch for type_match in type_match]

def get_nb_participants(id_tournoi):
participants_count = ParticipantsCompetition.query.join(Competition).filter(Competition.idComp == id_tournoi).count()
return participants_count

def filtrer_competitions(competitions, categorie, arme, sexe, statut):
comp_filtrer = competitions
if categorie:
comp_filtrer = [comp for comp in comp_filtrer if comp.categorie.nomCategorie == categorie]
if arme:
comp_filtrer = [comp for comp in comp_filtrer if comp.arme.nomArme == arme]
if sexe:
comp_filtrer = [comp for comp in comp_filtrer if comp.sexeComp == sexe]
if statut:
if statut == “A venir”:
comp_filtrer = [comp for comp in comp_filtrer if comp.dateComp > datetime.date.today()]
elif statut == “Terminé”:
comp_filtrer = [comp for comp in comp_filtrer if comp.dateComp <= datetime.date.today()]
return comp_filtrer

def filtrer_adherent(adherents, categorie, sexeE):
adherents_filtrer = adherents
if categorie:
adherents_filtrer = [adherent for adherent in adherents_filtrer if adherent.Categorie.nomCategorie == categorie]
if sexeE:
adherents_filtrer = [adherent for adherent in adherents_filtrer if adherent.Escrimeur.sexeE == sexeE]
# if role == ‘tireur’:
# adherents_filtrer = [adherent for adherent in adherents_filtrer if adherent.Arbitre is None]
# elif role == ‘arbitre’:
# adherents_filtrer = [adherent for adherent in adherents_filtrer if adherent.Arbitre is not None]
return adherents_filtrer

def get_id_lieu(nom_lieu):
lieu = Lieu.query.filter_by(nomLieu=nom_lieu).first()
return lieu.idLieu if lieu else None

def get_id_saison(nom_saison):
saison = Saison.query.filter_by(nomSaison=nom_saison).first()
return saison.idSaison if saison else None

def get_liste_participants_competitions_tireurs(id_comp):
return ParticipantsCompetition.query.join(Tireur, ParticipantsCompetition.numeroLicenceE == Tireur.numeroLicenceE).filter(ParticipantsCompetition.idComp == id_comp).all()

def get_liste_tireurs_escrimeurs_poule(id_comp, id_poule):
return Escrimeur.query.join(
Tireur, Escrimeur.numeroLicenceE == Tireur.numeroLicenceE
).join(
ParticipantsPoule, Tireur.numeroLicenceE == ParticipantsPoule.numeroLicenceE
).filter(
ParticipantsPoule.idComp == id_comp,
ParticipantsPoule.idPoule == id_poule
).all()



def get_club_tireur_escrimeur(tireur):
return Club.query.join(Tireur, Club.idClub == Tireur.idClub).filter(Tireur.numeroLicenceE == tireur.numeroLicenceE).first()

def get_arbitre_escrimeur_poule(id_comp, id_poule):
escrimeur = Escrimeur.query.join(Arbitre, Escrimeur.numeroLicenceE == Arbitre.numeroLicenceE).join(Poule, Arbitre.idArbitre == Poule.idArbitre).filter(Poule.idComp == id_comp).filter(Poule.idPoule == id_poule).first()
if escrimeur is not None:
return escrimeur
else:
return None

def get_id_arbitre_poule(id_comp, id_poule):
arbitre_poule = Arbitre.query.join(Poule, Arbitre.idArbitre == Poule.idArbitre).filter(Poule.idComp == id_comp).filter(Poule.idPoule == id_poule).first()
if arbitre_poule is not None:
return arbitre_poule.idArbitre
else:
return None
def get_piste_poule(id_comp, id_poule):
# retourne la piste de la poule de cette compétition
return Piste.query.join(Poule, Poule.idPiste == Piste.idPiste).filter(Poule.idComp == id_comp).filter(Poule.idPoule == id_poule).first()

def get_liste_participants_competitions_arbitres(id_comp):
return ParticipantsCompetition.query.join(Arbitre, ParticipantsCompetition.numeroLicenceE == Arbitre.numeroLicenceE).filter(ParticipantsCompetition.idComp == id_comp).all()

def get_classement_tireur(num_licence):
return Tireur.query.filter_by(numeroLicenceE=num_licence).first().classement

def get_id_club_tireur(num_licence):
return Tireur.query.filter_by(numeroLicenceE=num_licence).first().idClub

def get_id_arbitre_from_escrimeur(numero_licence):
arbitre = Arbitre.query.filter_by(numeroLicenceE=numero_licence).first()
if arbitre:
return arbitre.idArbitre

def get_nom_club_by_id(id_club):
return Club.query.filter_by(idClub=id_club).first().nomClub

def classer_tireurs(tireurs):
return sorted(tireurs, key=lambda tireur : get_classement_tireur(tireur.numeroLicenceE), reverse=True)

def poules_fabriquables(tireurs, arbitres):
return True if 3 <= len(tireurs) // len(arbitres) <= 7 and len(tireurs) > 3 else False

def nb_poules_fabriquables(arbitres):
return [[] for _ in range(len(arbitres))]

def get_nb_arbitres(id_comp):
return ParticipantsCompetition.query.join(Arbitre, ParticipantsCompetition.numeroLicenceE == Arbitre.numeroLicenceE).filter(ParticipantsCompetition.idComp == id_comp).count()

def get_nb_tireurs(id_comp):
return ParticipantsCompetition.query.join(Tireur, ParticipantsCompetition.numeroLicenceE == Tireur.numeroLicenceE).filter(ParticipantsCompetition.idComp == id_comp).count()

def get_liste_pistes_selon_nb_arbitres(id_comp, nb_arbitres):
return Piste.query.filter_by(idComp=id_comp).limit(nb_arbitres).all()



def fabriquer_poules_selon_classement(tireurs, arbitres, pistes):
if not poules_fabriquables(tireurs, arbitres):
return “Les poules ne sont pas fabriquables”

liste_triee = classer_tireurs(tireurs)
liste_poules = nb_poules_fabriquables(arbitres)
tireurs_dans_poule = set()
arbitres_dans_poule = set()
pistes_associees = set()
for i in range(len(liste_triee)):
if arbitres[i % len(arbitres)] not in arbitres_dans_poule and pistes[i % len(arbitres)] not in pistes_associees:
escrimeur = Escrimeur.query.filter_by(numeroLicenceE=arbitres[i].numeroLicenceE).first()
piste = pistes[i % len(arbitres)]
nom_complet = f”{escrimeur.prenomE} {escrimeur.nomE}, {piste.nomPiste}“
liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
arbitres_dans_poule.add(arbitres[i])
pistes_associees.add(pistes[i])
if liste_triee[i] not in tireurs_dans_poule and liste_triee[i] not in arbitres_dans_poule:
if len(liste_poules[i % len(arbitres)]) < 8:
escrimeur = Escrimeur.query.filter_by(numeroLicenceE=liste_triee[i].numeroLicenceE).first()
nom_complet = f”{escrimeur.prenomE} {escrimeur.nomE}, Classement : {get_classement_tireur(escrimeur.numeroLicenceE)}“
liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
tireurs_dans_poule.add(liste_triee[i])

if liste_triee[-i-1] not in tireurs_dans_poule and liste_triee[-i-1] not in arbitres_dans_poule:
if len(liste_poules[i % len(arbitres)]) < 8:
escrimeur = Escrimeur.query.filter_by(numeroLicenceE=liste_triee[-i-1].numeroLicenceE).first()
nom_complet = f”{escrimeur.prenomE} {escrimeur.nomE}, Classement : {get_classement_tireur(escrimeur.numeroLicenceE)}“
liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
tireurs_dans_poule.add(liste_triee[-i-1])
for i in range(len(liste_poules)):
if liste_poules[i].count(liste_poules[i][0]) > 1:
for j in range(len(liste_poules[i])):
if liste_poules[i][j] == liste_poules[i][0]:
liste_poules[i][j] = liste_poules[i].pop()
break


mal_trie = False
indice_mal_trie = None
for i in range(len(liste_poules)):
if len(liste_poules[i]) - 1 < 3:
mal_trie = True
indice_mal_trie = i
break
if mal_trie:
for i in range(len(liste_poules)):
if len(liste_poules[i]) - 1 > 3:
liste_poules[indice_mal_trie].append(liste_poules[i].pop())
break
return liste_poules

def fabriquer_poules_decalage_club(tireurs, arbitres, pistes):
if not poules_fabriquables(tireurs, arbitres):
return “Les poules ne sont pas fabriquables”

liste_triee = classer_tireurs(tireurs)
liste_poules = nb_poules_fabriquables(arbitres)
num_poule = 0
arbitres_dans_poule = set()
pistes_associees = set()
tireurs_dans_poule = set()
for i in range(len(liste_triee)):
if arbitres[i % len(arbitres)] not in arbitres_dans_poule and pistes[i % len(arbitres)] not in pistes_associees:
escrimeur = Escrimeur.query.filter_by(numeroLicenceE=arbitres[i].numeroLicenceE).first()
piste = pistes[i % len(arbitres)]
nom_complet = f”{escrimeur.prenomE} {escrimeur.nomE}, {piste.nomPiste}“
liste_poules[i].append((escrimeur, nom_complet))
arbitres_dans_poule.add(arbitres[i])
pistes_associees.add(pistes[i % len(arbitres)])
if liste_triee[i] not in tireurs_dans_poule and liste_triee[i] not in arbitres_dans_poule:
if len(liste_poules[i % len(arbitres)]) < 8:
escrimeur = Escrimeur.query.filter_by(numeroLicenceE=liste_triee[i].numeroLicenceE).first()
id_club_tireur = get_id_club_tireur(escrimeur.numeroLicenceE)
nom_club_tireur = get_nom_club_by_id(id_club_tireur)
nom_complet = f”{escrimeur.prenomE} {escrimeur.nomE}, Club : {nom_club_tireur}"
if (escrimeur, nom_complet) not in liste_poules[i % len(arbitres)]:
liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
else:
num_poule += 1
if num_poule % len(arbitres) == 0:
liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
num_poule = 0
else:
liste_poules[i % len(arbitres) + num_poule].append((escrimeur, nom_complet))
mal_trie = False
indice_mal_trie = None
for i in range(len(liste_poules)):
if len(liste_poules[i]) - 1 < 3:
mal_trie = True
indice_mal_trie = i
break
if mal_trie:
for i in range(len(liste_poules)):
if len(liste_poules[i]) - 1 > 3:
liste_poules[indice_mal_trie].append(liste_poules[i].pop())
break
for i in range(len(liste_poules)):
for j in range(len(liste_poules[i])):
if liste_poules[i][j][0] in tireurs_dans_poule:
tireurs_dans_poule.remove(liste_poules[i][j][0])
return liste_poules

def fabriquer_poules(tireurs, arbitres, pistes, type_poule):
if not poules_fabriquables(tireurs, arbitres):
return “Les poules ne sont pas fabriquables”
match type_poule:
case “Classement”:
liste_poules = fabriquer_poules_selon_classement(tireurs, arbitres, pistes)
case “Club”:
liste_poules = fabriquer_poules_decalage_club(tireurs, arbitres, pistes)
return liste_poules


def get_nb_arbitres(id_comp):
return ParticipantsCompetition.query.join(Arbitre, ParticipantsCompetition.numeroLicenceE == Arbitre.numeroLicenceE).filter(ParticipantsCompetition.idComp == id_comp).count()

def get_nb_tireurs(id_comp):
return ParticipantsCompetition.query.filter_by(idComp=id_comp).count() - get_nb_arbitres(id_comp)

def get_nb_poules(id_comp):
return Poule.query.filter_by(idComp=id_comp).count()

def get_adherents():
res = db.session.query(Tireur, Escrimeur, Categorie) <br/> .join(Escrimeur, Escrimeur.numeroLicenceE == Tireur.numeroLicenceE) <br/> .join(Club, Club.idClub == Tireur.idClub) <br/> .join(Categorie, Escrimeur.idCat == Categorie.idCat) <br/> .filter(Club.nomClub == “BLOIS CE”) <br/> .add_columns(
Tireur.idClub,
Escrimeur.prenomE,
Escrimeur.nomE,
Escrimeur.dateNaissanceE,
Escrimeur.numeroLicenceE,
Escrimeur.sexeE,
Escrimeur.numTelE,
Categorie.nomCategorie
) <br/> .all()
return res

def get_adherents_adapte_json(gender=None):
gender_filter = None
if gender == ‘H’:
gender_filter = “Homme”
elif gender == “F”:
gender_filter = “Femme”
query = db.session.query(Escrimeur).join(Tireur, Escrimeur.numeroLicenceE == Tireur.numeroLicenceE).join(Club, Club.idClub == Tireur.idClub).join(Categorie, Escrimeur.idCat == Categorie.idCat).filter(Club.nomClub == “BLOIS CE”)
if gender_filter is not None:
query = query.filter(Escrimeur.sexeE == gender_filter)
return query.all()

def dernier_escrimeur_id():
last_escrimeur = db.session.query(Escrimeur).order_by(Escrimeur.numeroLicenceE.desc()).first()
if last_escrimeur:
return last_escrimeur.numeroLicenceE
else:
return 0

def get_participants(id_comp, club=None):
res = (
db.session.query(ParticipantsCompetition, Escrimeur, Categorie)
.join(Escrimeur, ParticipantsCompetition.numeroLicenceE == Escrimeur.numeroLicenceE)
.join(Categorie, Escrimeur.idCat == Categorie.idCat)
.join(Tireur, Tireur.numeroLicenceE == Escrimeur.numeroLicenceE)
.join(Club, Club.idClub == Tireur.idClub)
.outerjoin(Arbitre, Arbitre.numeroLicenceE == Escrimeur.numeroLicenceE)
.filter(ParticipantsCompetition.idComp == id_comp)
.filter(Arbitre.idArbitre == None)
)
if club is not None:
if club == “!”:
res = res.filter(Club.nomClub != “BLOIS CE”)
else:
res = res.filter(Club.nomClub == club)
return res.add_columns(Escrimeur.prenomE, Escrimeur.nomE, Categorie.nomCategorie).all()

def get_liste_participants_competitions(id_comp):
return ParticipantsCompetition.query.filter_by(idComp=id_comp).all()

def get_informations_escrimeur(numero_licence):
return Escrimeur.query.filter_by(numeroLicenceE=numero_licence).first()

def get_id_poule(id_comp, id_piste, id_arbitre, nom_poule):
poule = Poule.query.filter_by(idComp=id_comp, idPiste=id_piste, idArbitre=id_arbitre, nomPoule=nom_poule).first()
if poule:
return poule.idPoule
else:
return None

def get_arbitres(idcomp):
arbitres = db.session.query(Arbitre, Escrimeur, Categorie).join(Escrimeur, Arbitre.numeroLicenceE == Escrimeur.numeroLicenceE).join(
Categorie, Escrimeur.idCat == Categorie.idCat
).join(
ParticipantsCompetition,
ParticipantsCompetition.numeroLicenceE == Escrimeur.numeroLicenceE
).filter(ParticipantsCompetition.idComp == idcomp).all()
return arbitres

def get_competition_statut(competition):
participants = ParticipantsCompetition.query.filter_by(idComp=competition.idComp).first()
if participants:
# verifie si les poules ont été créées pour la compétition
poules = Poule.query.filter_by(idComp=competition.idComp).first()
if poules:
# verifie si l’appel a été fait donc sil ya des scores entrés pour des matchs de poules)
try:
match_poule = Match.query.filter_by(idComp=competition.idComp).first()
except:
match_poule = None
if match_poule and (match_poule.touchesRecuesTireur1 is not None or match_poule.touchesDonneesTireur1 is not None
or match_poule.touchesRecuesTireur2 is not None or match_poule.touchesDonneesTireur2 is not None):
return ‘score’
else:
return ‘appel’
else:
return ‘participants’
else:
return ‘participants’

def get_tireurs_from_poule(poule_id):
return Tireur.query.join(ParticipantsPoule, Tireur.numeroLicenceE == ParticipantsPoule.numeroLicenceE).filter(ParticipantsPoule.idPoule == poule_id).all()

def count_victoires_for_tireur(tireur_num_licence):
return Match.query.filter(Match.numeroLicenceE1 == tireur_num_licence, Match.touchesDonneesTireur1 > Match.touchesDonneesTireur2).count() + Match.query.filter(Match.numeroLicenceE2 == tireur_num_licence, Match.touchesDonneesTireur2 > Match.touchesDonneesTireur1).count()

def sum_touches_donnees_for_tireur(tireur_num_licence):
sum1 = Match.query.filter(Match.numeroLicenceE1 == tireur_num_licence).with_entities(func.sum(Match.touchesDonneesTireur1)).scalar()
sum2 = Match.query.filter(Match.numeroLicenceE2 == tireur_num_licence).with_entities(func.sum(Match.touchesDonneesTireur2)).scalar()
return (sum1 if sum1 is not None else 0) + (sum2 if sum2 is not None else 0)

def sum_touches_recues_for_tireur(tireur_num_licence):
sum1 = Match.query.filter(Match.numeroLicenceE1 == tireur_num_licence).with_entities(func.sum(Match.touchesRecuesTireur1)).scalar() or 0
sum2 = Match.query.filter(Match.numeroLicenceE2 == tireur_num_licence).with_entities(func.sum(Match.touchesRecuesTireur2)).scalar() or 0
return sum1 + sum2

def get_poule_stats(poule_id):
poule_stats = {}
tireurs = get_tireurs_from_poule(poule_id)
for tireur in tireurs:
victoires = count_victoires_for_tireur(tireur.numeroLicenceE)
touches_donnees = sum_touches_donnees_for_tireur(tireur.numeroLicenceE)
touches_recues = sum_touches_recues_for_tireur(tireur.numeroLicenceE)
poule_stats[tireur.numeroLicenceE] = {
‘V’: victoires,
‘TD’: touches_donnees,
‘TR’: touches_recues,
‘TD-TR’: touches_donnees - touches_recues
}
return poule_stats

def get_matchs_poules(poule_id, id_comp):
return db.session.query(Match).join(
Contenir,
Match.idMatch == Contenir.idMatch
).filter(
Contenir.idPoule == poule_id,
Contenir.idComp == id_comp
).all()


def est_terminer_match(idMatch):
match_poule = Match.query.filter_by(idMatch=idMatch).first()
return match_poule.touchesDonneesTireur1 >= match_poule.type_match.nbnbTouches or match_poule.touchesDonneesTireur2 >= match_poule.type_match.nbnbTouches

def est_terminer_poule(idPoule):
match_poules = Match.query.filter_by(idPoule=idPoule).all()
for match_poule in match_poules:
if not est_terminer_match(match_poule.idMatch):
return False
return True

def est_terminer_phase_poule(idComp):
poules = Poule.query.filter_by(idComp=idComp).all()
for poule in poules:
if not est_terminer_poule(poule.idPoule):
return False
return True


def get_tireur_by_licence(licence):
return Tireur.query.filter_by(numeroLicenceE=licence).first()

def get_match(tireur1, tireur2, id_poule, id_comp):
“”“Retourne le match d’une poule pour 2 tireurs et une compétition
“””
match = db.session.query(Match).join(
Contenir,
Match.idMatch == Contenir.idMatch
).filter(
Contenir.idPoule == id_poule,
Contenir.idComp == id_comp,
or_(
(Match.numeroLicenceE1 == tireur1) & (Match.numeroLicenceE2 == tireur2),
(Match.numeroLicenceE1 == tireur2) & (Match.numeroLicenceE2 == tireur1)
)
).first()
return match

def get_match_phase_elim(id_comp, id_type_match):
return Match.query.filter_by(idComp=id_comp, idTypeMatch=id_type_match).all()

#sql utile débug
# select idMatch, idPoule, idComp, numeroLicenceE1, numeroLicenceE2 from CONTENIR natural join MATCH where idComp = 24;
# select numeroLicenceE1, numeroLicenceE2, touchesRecuesTireur1,touchesDonneesTireur1, touchesDonneesTireur2, touchesRecuesTireur2 from MATCH;
# select count(numeroLicenceE1), idPoule, idComp, numeroLicenceE1, numeroLicenceE2 from CONTENIR natural join MATCH where idComp = 24 group by numeroLicenceE1;
# select count(numeroLicenceE1), idPoule, idComp, numeroLicencre idComp = 24 group by numeroLicenceE1;