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