def get_param_p4():
"""
Fonction qui traite la requête de verification de non existence des parametres la partie de p4
:returns
--------
Code 409 :
Si des parametres ont déjà été définis
Code 200 :
Si des parametres n'ont pas encore été définis.
"""
request.get_json(force=True)
id_partie, duree_tour, condition_victoire, Taille_plateau = request.json.get('id_partie'), \
request.json.get('duree_tour'), \
request.json.get('condition_victoire'), \
request.json.get('Taille_plateau')
if DAOparametres.verif_parametre(id_partie) == False:
response = {
"status_code": http_codes.ok,
"message": "Il n'y a pas de parametres actuellement"
} # code 200
return make_reponse(response, http_codes.ok) # code 200
elif DAOparametres.verif_parametre(id_partie) == True:
response = {
"status_code":
http_codes.conflict,
"message":
"Il y a déja des parametre à cette partie, methode PUT conséillé"
} #code409
return make_reponse(response, http_codes.conflict) #code409
def est_ce_mon_tour():
"""
Fonction qui traite la requête de vérification si c'est le tour d'un utilisateur
:returns
--------
Code 449 :
- Si ce n'est pas le tour de l'utilisateur.
Code 403 :
- Si l'utilisateur ne peut pas jouer son tour.
Code 200 :
Si c'est le tour de l'utilisateur.
"""
request.get_json(force=True)
id_partie, pseudo = request.json.get('id_salle'), request.json.get(
'pseudo')
print(
f"L'utilisateur {pseudo} demande si c'est son tour dans la salle {id_partie}."
)
aquiltour = DAOparties.get_aquiltour(id_partie)
self_ordre = DAOparticipation.get_position_ordre(pseudo, id_partie)
#mettre condition prochain tour != 1
if aquiltour == self_ordre: #c'est le tour du joueur qui demande
print(
f"C'est bien le tour de l'utilisateur {pseudo} dans la salle {id_partie}."
)
old_coup = DAOcoups.get_old_coup(id_partie, pseudo)
last_coup = DAOcoups.get_last_coup(id_partie)[0]
if old_coup[4] == 1:
print(
f"L'utilisateur {pseudo} peut jouer son tour dans la salle {id_partie}"
)
response = {
"status_code": http_codes.ok,
"message": "C'est ton tour"
} # code 200
return make_reponse(response, http_codes.ok) # code 200
elif old_coup[4] > 1:
print(
f"L'utilisateur doit passer son tour encore {old_coup[4]-1} fois. Il passe donc automatiquement son tour ici. "
)
DAOcoups.add_new_coup(id_partie, last_coup + 1, pseudo,
old_coup[3], old_coup[4] - 1)
response = {
"status_code": http_codes.forbidden,
"message": "C'est votre tour, mais vous ne pouvez pas jouer"
} # code 403
return make_reponse(response, http_codes.forbidden) # code 403
else: #ce n'est pas son tour de jouer
print(
f"Ce n'est pas le tour de l'utilisateur {pseudo} dans la salle {id_partie}."
)
response = {
"status_code": http_codes.retry_with,
"message": "Ce n'est pas votre tour"
} # code 449
return make_reponse(response, http_codes.retry_with) # code 449
def je_suis_pret():
"""
Fonction qui traite la requête de mis à jour du status d'être prêt.
:returns
--------
Code 400 :
Si la il y a un problème dans le jeu en entrée.
Code 200 :
Si la requête est correctement effecutée.
"""
request.get_json(force=True)
pseudo, id_salle, est_chef, jeu = request.json.get(
'pseudo'), request.json.get('id_salle'), request.json.get(
'est_chef'), request.json.get('jeu')
print(
f"L'utilisateur {pseudo} demande à être prêt dans la salle {id_salle}."
)
#-- on update le est_pret a True dans la table Participation
DAOparticipation.update_est_pret(pseudo, id_salle, 'True')
#-- on update le nombre de parties jouees
if jeu.lower() == 'p4':
old_number = DAOscores.get_nb_parties_jouees(pseudo, "P4")
DAOscores.update_nb_parties_jouees(pseudo, "P4", old_number + 1)
elif jeu.lower() == "oie":
old_number = DAOscores.get_nb_parties_jouees(pseudo, "Oie")
DAOscores.update_nb_parties_jouees(pseudo, "Oie", old_number + 1)
else:
print("erreur dans le nom du jeu")
response = {
"status_code": http_codes.bad,
"message": "Erreur dans le jeu"
} # code 400
return make_reponse(response, http_codes.bad) # code 400
print(
f"L'utilisateur {pseudo} a maintenant joué {old_number + 1} parties de {jeu}"
)
#-- on fait choisir la couleur à l'utilisateur
couleur = DAOparticipation.get_couleur(pseudo, id_salle)
print(
f"L'utilisateur {pseudo} est pret dans la table Participation pour la partie {id_salle} avec la couleur {couleur}."
)
#-- on update l'ordre de jeu dans la table Participation
DAOparticipation.update_ordre(pseudo, id_salle)
print(
f"L'utilisateur {pseudo} s'est vu attribué son ordre de jeu pour la partie {id_salle}."
)
response = {
"status_code": http_codes.ok,
"message": "Utilisateur pret."
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def quitter_salle():
"""
Fonction qui traite la requête "quitter une salle"
:returns
--------
Code 401 :
Si l'utilisateur est chef de salle est qu'il n'est pas le dernier dedans, il ne peut quitter la salle.
Code 200 :
Si l'utilisateur a bien quitté la salle.
"""
request.get_json(force=True)
pseudo, id_salle, est_chef_salle = request.json.get('pseudo'), \
request.json.get("id_salle"), request.json.get("est_chef_salle")
nb_places_libres = DAOparties.check_cb_places_libres(id_salle)
print(f"Le joueur {pseudo} demande à quitter la partie {id_salle}")
#-- pas la peine de vérifier si la salle existe car cette méthode n'est disponible que depuis une salle
#-- si l'utilisateur qui tente de quitter la salle est le chef de groupe, on vérifie si la salle est vide sauf lui.
if est_chef_salle:
#-- s'il est le dernier a quitter la salle, il la quitte, sinon, il ne peut pas la quitter.
if DAOparties.check_cb_places_libres(
id_salle) + 1 != DAOparties.check_cb_places_tot(id_salle):
print(
f"Le joueur {pseudo} est chef de la salle {id_salle} il ne peut la quitter car il n'est pas seul"
)
response = {
"status_code": http_codes.unauthorized,
"message": "Ne peut quitter la salle.",
"id_salle": id_salle
} # code 401
return make_reponse(response, http_codes.unauthorized) # code 401
#-- on retire le pseudo de la salle dans la salle participation et on ajoute une place de libre dans la salle dans la table Parties
DAOparties.delete_from_participation(id_salle, pseudo, nb_places_libres)
# -- on update le statut du joueur en_partie a False dans la table Utilisateur
DAOuser.update_en_partie_pseudo(pseudo, "False")
print(f"Le joueur {pseudo} quitte la salle {id_salle}")
#-- on vérifie si la salle est vide et si elle est vide on la supprime
if DAOparties.check_cb_places_libres(
id_salle) == DAOparties.check_cb_places_tot(id_salle):
DAOparties.delete_partie(id_salle)
print(
f"Il n'y a plus de joueur dans la salle {id_salle}, elle est donc supprimée"
)
response = {
"status_code": http_codes.ok,
"message": "Utilisateur supprimé de la salle.",
"id_salle": id_salle
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def gestion_tour_lancement_partie():
"""
Fonction qui traite la requête de mis à jour du status d'être prêt.
:returns
--------
Code 406 :
Si au moins un participant n'est pas pret.
Code 200 :
Si tous les participants sont prets.
Code 401 :
Si il n'y a plus de chef dans la partie.
"""
request.get_json(force=True)
pseudo, id_salle, est_chef = request.json.get('pseudo'), request.json.get(
'id_salle'), request.json.get('est_chef')
if est_chef:
print(
f"{pseudo}, chef de la salle {id_salle} aimerait savoir si tout le monde est pret pour pouvoir lancer la partie."
)
#-- on DAO pour savoir si tout le monde est pret dans la salle
if DAOparticipation.number_of_ready(
id_salle) == DAOparties.get_nbr_participants(
id_salle): #tout les participants sont prets
print(f"Tout le monde est pret dans la partie {id_salle}")
response = {
"status_code": http_codes.ok,
"message": "Tous les participants sont prets."
} # code 200
return make_reponse(response, http_codes.ok) # code 200
else: #au moins 1 participant n'est pas pret
print(f"Tout le monde n'est pas pret dans la partie {id_salle}")
response = {
"status_code": http_codes.not_acceptable,
"message": "Au moins un participant n'est pas pret."
} # code 406
return make_reponse(response,
http_codes.not_acceptable) # code 406
else:
print(
f"{pseudo} n'est pas chef de la salle {id_salle} et n'a donc rien à faire ici.."
)
response = {
"status_code":
http_codes.unauthorized,
"message":
"Vous n'etes pas chef de salle. Vous ne devriez pas être ici comme dirait Hagrid."
} # code 401
return make_reponse(response, http_codes.unauthorized) # code 401
def new_user():
"""
Fonction qui traite la requête de création d'un nouvel utilisateur
:returns
--------
Code 409 :
- Si l'identifiant est déjà utilisé.
- Si le pseudo est déjà utilisé.
Code 200 :
Si l'utilisateur a bien été ajouté à la base de donnée
"""
request.get_json(force=True)
username, hpassword, pseudo = request.json.get('username'), request.json.get('hpassword'),\
request.json.get('pseudo')
print(
f"Demande de création d'un nouvel utilisateur (username = {username}, "
f"pseudo = {pseudo}) dans la base de données.")
#-- on vérifie si un tel username n'existe pas déjà dans la DB
if DAOuser.does_username_exist(username):
print(
f"L'identifiant ({username}) existe déjà dans la base de données.")
response = {
"status_code": http_codes.conflict,
"message": "User already exists in the DB."
} #error 409
return make_reponse(response, http_codes.conflict)
#-- on vérifie si un tel pseudo n'existe pas déjà dans la DB
if DAOuser.does_pseudo_exist(pseudo):
print(f"Le pseudo ({pseudo}) existe déjà dans la base de données.")
response = {
"status_code": http_codes.conflict,
"message": "Pseudo already exists in the DB."
} #error 409
return make_reponse(response, http_codes.conflict)
#-- on ajoute le nouvel utilisateur (username, pseudo, hpassword) à la DB Utilisateur
DAOuser.add_user(username, pseudo, hpassword)
print("utilisateur ajouté dans la table Utilisateur.")
#-- on ajoute l'utilisateur à la db Score pour suivre ces classement
DAOuser.add_user_score(pseudo)
print("utilisateur ajouté dans la base Scores.")
#-- on renvoit le code ok et le message d'ajout de l'utilisateur.
response = {
"status_code": http_codes.ok,
"message": "L'utilisateur a bien été ajouté à la DB."
}
return make_reponse(response, http_codes.ok) #code 200
def supp_ami():
"""
Fonction qui traite la requête de suppression d'un utilisateur de la liste d'amis.
:returns
--------
Code 404 :
- Si l'identifiant fourni n'existe pas.
Code 208 :
- Si l'utilisateur n'est pas dans la liste d'amis.
Code 200 :
Suppression réussie.
"""
request.get_json(force=True)
pseudo, pseudo_ami = request.json.get('pseudo'), request.json.get(
'pseudo_ami')
print(
f"Demande de pseudo = {pseudo} de supprimer pseudo = {pseudo_ami} de sa liste d'amis."
)
#-- vérification si un utilisateur avec le pseudo_ami existe dans la DB
if not DAOuser.does_pseudo_exist(pseudo_ami):
print(
f"Le pseudo ({pseudo_ami}) à supprimer de la liste d'amis n'existe pas."
)
response = {
"status_code": http_codes.not_found,
"message": "L'ami à supprimer n'existe pas."
} # code 404
return make_reponse(response, http_codes.not_found) # code 404
# -- on vérifie si pseudo est bien ami avec pseudo_ami
if not DAOfriend.are_pseudos_friends(pseudo, pseudo_ami):
print(f"{pseudo} n'est déjà pas ami avec {pseudo_ami}.")
response = {
"status_code": http_codes.already_reported,
"message": "L'amitié n'existe pas."
} # code 208
return make_reponse(response, http_codes.already_reported) # code 208
# -- on effectue la procédure qui supprime le lien d'amitié
DAOfriend.sup_amitie(pseudo, pseudo_ami)
print(f"{pseudo_ami} a bien été supprimé de la liste d'ami de {pseudo}.")
#-- on renvoit le code ok et le message de suppression de l'ami.
response = {
"status_code": http_codes.ok,
"message": "Ami supprimé."
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def maj_param_partie_p4():
"""
Fonction qui traite la requête de mise à jour des parametres la partie de p4
:return
-------
Code 200 :
Si des parametres ont bien été mis à jour.
"""
request.get_json(force=True)
id_partie, duree_tour, condition_victoire, Taille_plateau = request.json.get('id_partie'), \
request.json.get('duree_tour'), \
request.json.get('condition_victoire'), \
request.json.get('Taille_plateau')
DAOparametres.put_parametre(id_partie, duree_tour, condition_victoire,
Taille_plateau)
print(
f"Les paramètres suivants : Durée d'un tour : {duree_tour} secondes \n Condition de victoire : aligner "
f"{condition_victoire} jetons \n Taille du plateau : {Taille_plateau} \n "
f"ont a bien été mis à jour pour la partie {id_partie}")
response = {
"status_code": http_codes.ok,
"message": "Parametre bien mis à jour"
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def is_salle_anonyme_dispo():
request.get_json(force=True)
pseudo, jeu = request.json.get("pseudo"), request.json.get("game")
id_salle = DAOparties.is_salle_anonyme_dispo(jeu.lower())
if id_salle == None: #aucune salle de dispo
response = {
"status_code": http_codes.not_found,
"message": "Aucune salle ne correspond à la demande."
} # code 404
return make_reponse(response, http_codes.not_found) # code 404
else:
response = {
"status_code": http_codes.ok,
"message": "AUne salle est disponible.",
"id_salle": id_salle[0]
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def gestion_fin_partie():
"""
Fonction qui traite la requête de gestion de fin de partie.
:return
--------
Code 200 :
Requête bien effecuté.
"""
request.get_json(force=True)
id_partie, jeu, pseudo, win_bool, ami_anonyme = request.json.get(
'id_partie'), request.json.get('jeu').upper(), request.json.get(
'pseudo'), request.json.get('win_bool'), request.json.get(
'ami_anonyme')
#-- on retire le joueur de la table participation
#en fait, on ne le retire pas de la table participation sinon les fin de parties vont bug chez les autres vu que les simulations ne pourront plus marcher.
#du coup, on met a jour le nb_de_place dans la table partie mais on ne retire pas de la table participation
#et seulement quand on supprime la table partie, on supprime toutes les occurances dans la table participatipon
nb_places_dispos = DAOparties.check_cb_places_libres(id_partie)
DAOparties.update_parties_nb_place(id_partie, nb_places_dispos + 1)
print(f"L'utilisateur {pseudo} a bien été retiré de la salle {id_partie}")
nbr_places_restantes = DAOparties.check_cb_places_libres(id_partie)
print(
f"La salle {id_partie} a dorénavant {nbr_places_restantes} de libres.")
if DAOparties.get_nbr_participants(
id_partie
) == 0: #si c'était le dernier joueur dans la salle, on supprime la salle
#avant de supprimer la salle, on récupère la liste de tous les joueurs de la salle
liste_players = DAOparticipation.get_all_players(id_partie)
print(f"Liste des joueurs dans la salle : " + str(liste_players))
for player in liste_players:
DAOparties.delete_from_participation(id_partie, player, -1)
#on supprimer egalement tous les coups de la table Coups
DAOcoups.delete_all_coups(id_partie)
DAOparties.delete_partie(id_partie)
print(f"La salle {id_partie} était vide et a donc été supprimée")
#-- si le joueur a gagné la partie, on lui ajoute un dans la table scores
if win_bool:
nb_parties_gagnnes = DAOscores.get_nb_parties_gagnees(pseudo, jeu)
DAOscores.update_nb_parties_gagnees(pseudo, jeu,
nb_parties_gagnnes + 1)
print(
f"L'utilisateur {pseudo} a dorenavant gagné {nb_parties_gagnnes+1} dans le jeu {jeu}"
)
#-- on update les points
DAOscores.update_score(pseudo, jeu, win_bool)
response = {"status_code": http_codes.ok, "message": ""} # code 200
return make_reponse(response, http_codes.ok) # code 200
def get_liste_couleur_dispos():
"""
Fonction qui traite la requête de verification des couleurs disponibles pour la partie.
:returns
--------
Code 403 :
Si il n'y a pas assez de joueur pour lancer la partie
Code 200 :
Si la requête peut être correctement effecutée.
"""
request.get_json(force=True)
id_partie = request.json.get("id_salle")
# -- on vérifie si il y a au moins 2 personnes dans la salle sinon il pourrait lancer une partie solo, ce qui casserait tout
if DAOparties.get_nbr_participants(id_partie) < 2:
print(
f"L'utilisateur ne peut pas être prêt dans la salle {id_partie} car il y est tout seul."
)
response = {
"status_code": http_codes.forbidden,
"message": "Pas assez d'utilisateurs dans la salle."
} # code 403
return make_reponse(response, http_codes.forbidden) # code 403
print(
f"La liste des couleurs disponibles pour la partie {id_partie} a été demandée."
)
#-- on récupère la liste des couleurs dispo
liste_couleurs_dispos = DAOparticipation.get_free_color(id_partie)
print(
f"La liste des couleurs disponibles pour la partie {id_partie} a été transmise."
)
response = {
"status_code": http_codes.ok,
"message": "",
"liste_couleurs_dispos": liste_couleurs_dispos
}
return make_reponse(response, http_codes.ok) # Code 200
def deconnect():
"""
Fonction qui traite la requête déconnexion d'un utilisateur
:returns
--------
Code 401 :
- Si le pseudo fourni est incorrecte.
Code 200 :
La décoonnexion réussie.
"""
request.get_json(force=True)
pseudo = request.json.get('pseudo')
print(f"Demande de déconenxion (pseudo = {pseudo}).")
# -- on vérifie si un utilisateur avec ce pseudo existe dans la DB
if not DAOuser.does_pseudo_exist(pseudo):
print(
f"Le pseudo ({pseudo}) du joueur qui demande sa déconnexion n'existe pas..."
)
response = {
"status_code": http_codes.unauthorized,
"message": "Pseudo incorrect."
} # error 401
return make_reponse(response, http_codes.unauthorized)
#-- on update le statut "est_connecte" à False de l'utilisateur qui vient de se deco via son pseudo
DAOuser.update_est_connecte(pseudo,
username_or_pseudo='pseudo',
nouvel_etat='False')
print(f"Utilisateur (pseudo = {pseudo}) déconnecté")
#-- on renvoit le code ok et le message.
response = {
"status_code": http_codes.ok,
"message": "Déconnection réussie."
}
return make_reponse(response, http_codes.ok) # code 200
def ajout_couleur():
"""
Fonction qui traite la requête de la selection d'une couleur par un utilisateur pour la partie.
:returns
--------
Code 409 :
Si la couleur sélectionné a déja été choisie par quelqu'un d'autre.
Code 200 :
Si la requête est correctement effecutée.
"""
request.get_json(force=True)
id_partie, pseudo, couleur = request.json.get(
"id_salle"), request.json.get("pseudo"), request.json.get("couleur")
#-- on vérifie d'abord que la couleur est tjrs libre
if not DAOparticipation.is_color_free(id_partie, couleur):
print(
f"La couleur {couleur} a été prise par un autre joueur entre temps dans la partie {id_partie}."
)
liste_couleurs_dispos = DAOparticipation.get_free_color(id_partie)
response = {
"status_code": http_codes.conflict,
"message":
"La couleur été libre mais a été sélectionnée par un autre joueur entre temps.",
"liste_couleurs_dispos": liste_couleurs_dispos
}
return make_reponse(response, http_codes.conflict) #code 409 conflict
#-- on update la db pour mettre la couleur
DAOparticipation.update_color(pseudo, id_partie, couleur)
print(
f"Le joueur {pseudo} a choisi la couleur {couleur} dans la partie {id_partie}."
)
response = {"status_code": http_codes.ok, "message": ""}
return make_reponse(response, http_codes.ok)
def get_grille():
"""
Fonction qui traite la requête de recuperation de la grille de jeu.
:return
--------
Code 200 :
La requète réussie.
"""
request.get_json(force=True)
id_partie, jeu = request.json.get('id_partie'), request.json.get('jeu')
print(
f"La grille est demandée dans la salle {id_partie} pour le jeu {jeu}")
#-- on requete la DB pour obtenir l'ensemble des coups qui ont eu lieu dans une partie
liste_coups = DAOcoups.get_all_coups(id_partie)
print("Liste des coups : " + str(liste_coups))
if jeu.lower() == "p4":
#-- on envoit cette liste à jeux service qui va simuler tous les coups et renvoyer la grille dans cet etat
plateau = GridP4(
numHeight=7, numWidth=7, tokenWinNumber=4
) #pour l'instant, on ne travaille que avec des parties par default
plateau.simulatation(liste_coups)
grille = plateau.getGrid()
elif jeu.lower() == 'oie':
plateau = Tray(
numofdice=2, numoffaces=6, nbBox=63, id_partie=id_partie
) #pour le moment, on ne joue qu'avec des valeurs standards
grille = plateau.simulation(liste_coups)
print(f"grille oie : {grille}")
print(f"La grille a été simulée dans la salle {id_partie}")
#-- on recupère aussi une liste donnant les couleurs dans l'ordre pour l'affichage couleur
#liste = [rouge, bleu, vert] car le joueur etant premier dans l'ordre a la couleur rouge, le 2nd vert, etc...
liste_couleur = DAOparticipation.get_liste_couleur(id_partie)
print(f"La liste des couleurs ordonnee fournit {liste_couleur}")
response = {
"status_code": http_codes.ok,
"message": "Grille simulée",
'grid': grille,
'liste_couleur_ordonnee': liste_couleur
} # code 200
return make_reponse(dict(response), http_codes.ok) # code 200
def lancer_partie():
"""
Fonction qui traite la requête de lancement de partie.
:return
-------
Code 200 :
Si la requête a bien été effectuée.
"""
request.get_json(force=True)
id_partie = request.json.get('id_salle')
#-- on DAO pour update la table partie et mettre statut = 'en cours'
DAOparties.lancer_partie(id_partie)
response = {
"status_code": http_codes.ok,
"message": "Partie lancée"
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def creer_salle():
"""
Fonction qui traite la requête de création d'une salle pour jouer.
:return
-------
Code 200 :
Si la salle a bien été créée.
"""
request.get_json(force=True)
pseudo_chef, game, ami_anonyme = request.json.get(
'pseudo_chef_salle'), request.json.get('game'), request.json.get(
'ami_anonyme')
print(f"{pseudo_chef} créée une salle pour jouer au jeu : {game}.")
if game.lower() == 'p4':
total_places = 2
print("Nombre de place maximum : 2")
elif game.lower() == 'oie':
total_places = 5
print("Nombre de place maximum : 5")
#-- fonction qui créé la partie dans la table et qui renvoit son id
id_partie = DAOparties.add_partie(pseudo_chef, game, total_places,
ami_anonyme)
print(
f"création de la salle {id_partie} pour la partie de {pseudo_chef} sur le jeu : {game}. Salle pour jouer contre {ami_anonyme}"
)
#-- on ajoute le joueur directement à sa salle dans la table participation
nb_places_libres = DAOparties.check_cb_places_libres(id_partie)
DAOparties.add_to_participation(id_partie, pseudo_chef, nb_places_libres)
print(
f"Il y a {nb_places_libres-1} place.s libre.s dans la salle {id_partie}"
)
#-- on update le statut du joueur en_partie a True dans la table Utilisateur
DAOuser.update_en_partie_pseudo(pseudo_chef, "True")
print(f"Mise a jours du status de {pseudo_chef}")
# -- on renvoit le code ok, le message et l'id de la partie créée.
response = {
"status_code": http_codes.ok,
"message": "Salle créée. Joueur ajouté à la salle.",
"id_salle": id_partie
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def demander_si_vainqueur():
"""
Fonction qui traite la requête de vérification si il y a un vainqueur.
:return
--------
Code 200 :
Si il y a bien un vainqueur.
"""
request.get_json(force=True)
id_partie, jeu = request.json.get('id_partie'), request.json.get('jeu')
print(
f"Demande de savoir si la grille de la salle {id_partie} est gagnante dans le jeu {jeu} "
)
if jeu.lower() == 'p4':
plateau = GridP4(
numHeight=7, numWidth=7, tokenWinNumber=4
) # pour l'instant, on ne travaille que avec des parties par default
plateau.simulatation(DAOcoups.get_all_coups(id_partie))
Bool = plateau.TestIfWin()
elif jeu.lower() == 'oie':
plateau = Tray(
numofdice=2, numoffaces=6, nbBox=63, id_partie=id_partie
) # pour l'instant, on ne travaille que avec des parties par default
dico = plateau.simulatation(DAOcoups.get_all_coups(id_partie))
for player in dico:
Bool = plateau.TestIfWin(player._actualbox)
if Bool:
break
if Bool:
print(f"La partie {id_partie} est gagnante")
else:
print(f"La partie {id_partie} n'est pas gagnante")
response = {
"status_code": http_codes.ok,
"message": "",
"is_winner": Bool
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def passer_son_tour():
"""
Fonction qui traite la requête de passage de tour d'un joueur.
:return
--------
Code 200 :
La requète réussie.
"""
request.get_json(force=True)
id_partie, pseudo = request.json.get('id_salle'), request.json.get(
'pseudo')
print(f"Le joueur {pseudo} passe son tour dans la salle {id_partie}")
#-- on update aquiltour en faisant bien attention a ce qu'un foie que le dernier à jouer ça revient au premier
DAOparties.update_aquiltour(id_partie)
response = {
"status_code": http_codes.ok,
"message": "Aquiltour updaté"
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def voir_membres_salle():
"""
Fonction qui traite la requête d'affichage des membres de la salle.
:return
--------
Code 200 :
Si la requête a bien été exécutée.
"""
request.get_json(force=True)
id_salle = request.json.get("id_salle")
print(f"Demande d'affichage des membres de la salle {id_salle}")
#-- on affiche les membres de cette salle
membres = DAOparties.get_membres_salle(id_salle)
print(f"Les membres de la salle {id_salle} sont : {membres}")
response = {
"status_code": http_codes.ok,
"message": "Liste des membres de la salle.",
"liste_membres": membres
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def afficher_classement_general():
"""
Fonction qui traite la requête d'affichage du classement général.
:return
--------
Code 200 :
Affichage réussi.
"""
request.get_json(force=True)
pseudo = request.json.get("pseudo")
print(f" Demande de {pseudo} d'accès au classement général")
#-- on récupère le classement général
classement_general = DAOclassement.afficher_classement_general(pseudo)
print(f"Récupération classement mondial")
classement_general_amis = DAOclassement.afficher_classement_general_friends(pseudo)
print(f"Récupération classement amis de {pseudo}")
# -- on renvoit le code ok, le message et le classement général
response = {"status_code": http_codes.ok, "message": "Classement général récupéré.",
"classement_general": classement_general, "classement_general_amis"
"": classement_general_amis} # code 200
return make_reponse(response, http_codes.ok) # code 200
def afficher_liste_amis():
"""
Fonction qui traite la requête d'affichage la liste d'amis.
:return
--------
Code 200 :
Affichage réussie.
"""
request.get_json(force=True)
pseudo = request.json.get('pseudo')
print(f"Demande d'affichage de la liste d'amis de pseudo = {pseudo}.")
#-- on récupère la liste des amis
liste_amis = DAOfriend.afficher_liste_amis(pseudo)
print(f"Liste d'amis transmise.")
#-- on renvoit le code ok, le message et la liste des amis.
response = {
"status_code": http_codes.ok,
"message": "Liste des amis récupérée.",
'liste_amis': liste_amis
} #code 200
return make_reponse(response, http_codes.ok) # code 200
def afficher_classement():
"""
Fonction qui traite la requête d'affichage du classement d'un jeu.
:return
--------
Code 200 :
Affichage réussi.
"""
request.get_json(force=True)
nom_jeu = request.json.get("nom_jeu")
pseudo = request.json.get("pseudo")
print(f" Demande de {pseudo} d'accès au classement du jeu : {nom_jeu}")
#-- on récupère le classement du jeu de l'oie
classement_jeu = DAOclassement.afficher_classement_jeu(nom_jeu,pseudo)
print(f"Récupération classement mondial du jeu : {nom_jeu}")
classement_jeu_amis = DAOclassement.afficher_classement_jeu_friends(nom_jeu, pseudo)
print(f"Récupération classement amis de {pseudo} du jeu : {nom_jeu}")
#-- on renvoit le code ok, le message et le classement du jeu de l'oie
response = {"status_code": http_codes.ok, "message": "Classement du jeu récupéré.",
'classement_jeu': classement_jeu,'classement_jeu_amis': classement_jeu_amis}
#response2 = {"status_code": http_codes.ok, "message": "Classement du l'oie récupéré.", 'classement_jeu_amis': classement_jeu_amis} #code 200#code 200 #####
return make_reponse(response, http_codes.ok) # code 200
def rejoindre_salle():
"""
Fonction qui traite la requête "rejoindre une salle"
:returns
--------
Code 404 :
- Si le numéro de salle entré est inexistant.
- Si le jeu séléctionné ne correspond pas.
Code 401 :
Si la salle est déjà pleine.
Code 200 :
Si l'utilisateur a bien rejoint la salle.
"""
request.get_json(force=True)
pseudo, id_salle, jeu = request.json.get('pseudo'), request.json.get(
"id_salle"), request.json.get("jeu")
print(
f"Le joueur {pseudo} demande à rejoindre la salle {id_salle} sur le jeu : {jeu}"
)
#-- on vérifie si la salle existe
if not DAOparties.does_partie_exist(id_salle):
print(f"La salle {id_salle} a rejoindre n'existe pas.")
response = {
"status_code": http_codes.not_found,
"message": "Salle inexistante.",
"id_salle": id_salle
} # code 404
return make_reponse(response, http_codes.not_found) # code 404
#-- on vérifie si il y a assez de place dans la salle
nb_places_libres = DAOparties.check_cb_places_libres(id_salle)
if nb_places_libres == 0:
print(f"La salle {id_salle} est déjà pleine.")
response = {
"status_code": http_codes.unauthorized,
"message": "Salle déjà pleine.",
"id_salle": id_salle
} # code 401
return make_reponse(response, http_codes.unauthorized) # code 401
#-- on vérifie si le jeu de la salle correspond bien à notre jeu
jeu_salle = DAOparties.get_jeu_salle(id_salle)[0][0]
print(f"le jeu actuel de salle de la salle est : {jeu_salle}")
print(f"{pseudo} veut jouer à {jeu}")
if jeu != jeu_salle:
print("les jeux sont différents, la salle désirée n'existe pas")
response = {
"status_code": http_codes.not_found,
"message": "Salle inexistante.",
"id_salle": id_salle
} # code 404
return make_reponse(response, http_codes.not_found) # code 404
#-- on ajoute l'utilisateur a la salle
print("les jeux sont les même")
DAOparties.add_to_participation(id_salle, pseudo, nb_places_libres)
# -- on update le statut du joueur en_partie a True dans la table Utilisateur
DAOuser.update_en_partie_pseudo(pseudo, "True")
print(
f"{pseudo} a bien rejoint la salle {id_salle} pour jouer à {jeu_salle}"
)
response = {
"status_code": http_codes.ok,
"message": "Utilisateur ajouté à la salle.",
"id_salle": id_salle
} # code 200
return make_reponse(response, http_codes.ok) # code 200
def identification():
"""
Fonction qui traite la requête d'identification d'un utilisateur
:returns
--------
Code 401 :
- Si l'identifiant fourni n'existe pas.
- Si le mot de passe est incorrecte.
Code 403 :
- Si l'utilisateur est déjà connecté.
Code 200 :
La Connexion réussie.
"""
request.get_json(force=True)
username, password = request.json.get('username'), request.json.get(
'password')
print(f"Demande d'identification (identifiant ={username}).")
#-- on vérifie si un utilisateur avec cet identifiant existe dans la DB
if not DAOuser.does_username_exist(username):
print(f"L'identifiant founit ({username}) est incorrect.")
response = {
"status_code": http_codes.unauthorized,
"message": "Username incorrect."
} #error 401
return make_reponse(response, http_codes.unauthorized)
#-- on récupère le hpass associé à l'utilisateur et on le compare au hash du mdp fournit pour la connection
stored_hpass = DAOuser.get_hpass_username(username)
if not MDPgestion.verify_password(stored_hpass, password):
print(
"Le mot de passe fournit ne correspond pas à celui stocké en base."
)
response = {
"status_code": http_codes.unauthorized,
"message": "Password incorrect."
} # error 401
return make_reponse(response, http_codes.unauthorized)
#-- on vérifie que l'utilisateur n'est pas déjà conencté
if DAOuser.get_est_connecte(username): #l'utilisateur est déjà connecté
print(
f"L'utilisateur ({username}) est déjà connecté et ne peut donc pas se reconnecter."
)
response = {
"status_code": http_codes.forbidden,
"message": "User already connected."
} # error 403
return make_reponse(response, http_codes.forbidden)
#-------------------------- Connexion réussie -----------------------------
#-- on update le statut "est_connecte" à True de l'utilisateur qui vient de se connecter
DAOuser.update_est_connecte(username,
username_or_pseudo='username',
nouvel_etat='True')
#-- on renvoit le code ok, le message et le pseudo
pse = DAOuser.get_pseudo(username)
print("Utilisateur connecté.")
response = {
"status_code": http_codes.ok,
"message": "Connection réussie.",
"pseudo": pse
}
return make_reponse(response, http_codes.ok) # code 200
def get():
"""
Base route
"""
response = {"status_code": http_codes.OK, "message": "Vous êtes bien sur l'Api jeux"}
return make_reponse(response, http_codes.OK)
def jouer_son_tour():
"""
Fonction qui traite la requête "jouer son tour" d'un utilisateur
:returns
--------
Code 401 :
- Si l'identifiant fourni n'existe pas.
- Si le mot de passe est incorrecte.
Code 403 :
- Si l'utilisateur est déjà connecté.
Code 200 :
La Connexion réussie.
"""
request.get_json(force=True)
id_partie, pseudo, jeu = request.json.get('id_partie'), request.json.get(
'pseudo'), request.json.get('jeu')
position = request.json.get('position')
if type(position) == float:
dice1, dice2 = math.floor(position), round((position % 1) * 10)
position2 = [dice1, dice2]
print(
f"L'utilisateur {pseudo} joue la position {position} pour le jeu {jeu}"
)
if jeu.lower() == "p4":
coup = {'player': pseudo, 'id_partie': id_partie, 'colonne': position}
print(
f"L'utilisateur {pseudo} va jouer son tour dans la salle {id_partie} au P4. Il a joué dans la colonne {position}."
)
elif jeu.lower() == "oie":
coup = {
'player': pseudo,
'id_partie': id_partie,
'dice1': position2[0],
'dice2': position2[1]
}
print(
f"L'utilisateur {pseudo} va jouer son tour dans la salle {id_partie} au jeu de l'oie. Il a joué un {position2[0]} et un {position2[1]}."
)
#-- on demande a jeux service si le coup est valide
if jeu.lower() == "p4":
plateau = GridP4(
numHeight=7, numWidth=7, tokenWinNumber=4
) # pour l'instant, on ne travaille que avec des parties par default
plateau.simulatation(DAOcoups.get_all_coups(id_partie))
jeu = GameP4(id_partie)
Resultat = jeu.is_coup_valide(coup=coup, gridClass=plateau)
elif jeu.lower() == 'oie':
if not 0 < position2[0] < 7 or not 0 < position2[1] < 7:
print(
f"Erreur dans les dés pour {pseudo} dans la salle {id_partie}")
Resultat = {
"Statut": False,
"Message": "Au moins l'un des 2 dés à une valeur innapropriée."
}
else:
Resultat = {
"Statut": True,
"Message": "Pas de problèmes dans les dés."
}
if not Resultat["Statut"]: #le coup n'est pas valide
print(f"Le coup n'est pas valide")
response = {
"status_code": http_codes.forbidden,
"message": Resultat["Message"]
} # code 403
return make_reponse(response, http_codes.forbidden) # code 403
print("Le coup est valide")
#-- on enregistre ce coup dans la bd
last_coup = DAOcoups.get_last_coup(id_partie)[
0] #valeur du num_turn_précédent
DAOcoups.add_new_coup(id_partie,
math.floor(last_coup) + 1, pseudo, position, 1)
print("Le coup a été enregistré dans la DB")
response = {
"status_code": http_codes.ok,
"message": "Coup joué et ajouté à la DB"
} # code 200
return make_reponse(response, http_codes.ok) # code 200
