def deconnexion(self):
"""
Foction qui gère la déconnexion d'un utilisateur.
Returns
-------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette commande ainsi que le message associé
Si l'utilisateur s'est déconnecté normalement, le statut sera le booléen True.
Sinon, le statut sera le booléen False, avec la raison de cette echec dans le message associé.
"""
relative_address = "/home/deconnexion"
adresse = make_address(absolute_address, relative_address)
dataPost = {'pseudo': self.pseudo}
# -- connexion à l'API
res = requests.get(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True)
elif res.status_code == 404:
Resultat = self.update_resultat(False, "erreur, l'api n'a pas été trouvée")
elif res.status_code == 500:
Resultat = self.update_resultat(False, "erreur dans le code de l'api")
else:
Resultat = self.update_resultat(False, "erreur non prévue : " + str(res.status_code))
return Resultat
def demander_si_vainqueur(self):
"""
Fonction qui vérifie si l'utilisateur remporte la partie.
Returns
-------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette vérification ainsi que le message associé.
Si l'utilisateur a remporté la partie, le statut sera le booléen True.
Sinon, le statut sera le booléen False dans les cas suivant:
-Le joueur n'a pas remporté la partie
-Une erreur quelconque a eu lieu, dans ce cas, le message associé le précisera.
"""
relative_address = "/home/game/room/grid"
adresse = make_address(absolute_address, relative_address)
dataPost = {'id_partie': self.id_salle, 'jeu': self.jeu.lower()}
res = requests.put(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
winner_bool = res.json()["is_winner"]
if winner_bool:
Resultat = self.update_resultat(True,
"Vous avez gagné la partie")
else:
Resultat = self.update_resultat(False)
else:
Resultat = self.update_resultat(
False, "erreur dans PlayerClass.jouer_son_tour")
return Resultat
def demander_grille(self):
"""
Fonction qui gère une demande d'affichage de la grille de jeu.
Returns
-------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'affichage de cette grille ainsi que le message associé
Si la demande est bien traitée, le statut sera le booléen True et le dictionnaire renverra aussi
la grille et la liste des couleurs sélectionné ardonnée.
Sinon le statut sera le booléen False.
"""
relative_address = "/home/game/room/grid"
adresse = make_address(absolute_address, relative_address)
dataPost = {'id_partie': self.id_salle, 'jeu': self.jeu.lower()}
res = requests.get(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True)
Resultat["Grille"] = res.json()["grid"]
Resultat["liste_couleur_ordonnee"] = res.json(
)["liste_couleur_ordonnee"]
else:
Resultat = self.update_resultat(
False, "erreur dans PlayerClass.demander_grille")
return Resultat
def lancer_partie(self):
"""
Fonction qui gère le lancement d'une partie.
Returns
-------
Resultat: dict
Dictionnaire contenant la réussite ou non de ce lancement et le message associé.
Si la partie s'est bien lancée, le statut sera le booléen True.
Sinon, le statut sera le booléen False. La cause sera justifiée dans le message associé
"""
relative_address = "/home/game/room/launch"
adresse = make_address(absolute_address, relative_address)
dataPost = {'id_salle': self.id_salle}
res = requests.post(
adresse, data=json.dumps(dataPost)
) # dao pour modifier dans la table Partie le statut à en cours
if res.status_code == 200:
# la partie est lancée, on peut requeter pour savoir si c'est son tour
Resultat = self.update_resultat(True)
else:
Resultat = self.update_resultat(
False, "erreur dans PlayerClass.lancer_partie")
return Resultat
def reinitialiser_stats_perso(self):
"""
Fonction qui gère la demande de réinitialisation des statistiques de l'utilisateur.
Returns
------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette commande ainsi que le message associé
Si le traitement de la demande de réinitialisation est faite sans accroc, le statut sera le booléen True.
Sinon, le statut sera le booléen False, avec la raison de cette echec dans le message associé.
"""
relative_address = "/home/main/profil/user/stat"
adresse = make_address(absolute_address, relative_address)
dataPost = {'pseudo': self.pseudo}
res = requests.put(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True, "Vos statistiques ont bien été réinitialisées")
elif res.status_code == 404:
Resultat = self.update_resultat(False, "erreur, l'api n'a pas été trouvée")
elif res.status_code == 500:
Resultat = self.update_resultat(False, "erreur dans le code de l'api")
else:
Resultat = self.update_resultat(False, "erreur non prévue : " + str(res.status_code))
return Resultat
def etre_pret(self):
"""
Fonction qui permet à un utilisateur se mettre prêt à débuter une partie.
Returns
------
Resultat: dict
Dictionnaire contenant la réussite ou non de l'actualisation du statut de l'utilisateur et le message associé
Si l'actualisation a bien eu lieu, le statut sera le booléen True.
Sinon, une erreur est relevée, le statut sera le booléen False. Le message associé justifiera
la cause de l'erreur.
"""
relative_address = "/home/game/room/turns"
adresse = make_address(absolute_address, relative_address)
dataPost = {
'pseudo': self.pseudo,
'id_salle': self.id_salle,
'est_chef': self.est_chef,
'jeu': self.jeu
}
res = requests.post(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True, "Vous êtes prêts!")
else:
Resultat = self.update_resultat(
False, "erreur ndas PlayerClass.choix_couleur")
return Resultat
def is_everyone_ready(self):
"""
Fonction qui gère la verification du status de tous les utilisateurs. Ansi elle s'assure que tous les utilisateurs
sont prêts à jouer
Returns
-------
Resultat: dict
Dictionnaire contenant la réussite ou non de la véfication i.e si tout le monde est prêt et le message associé
Si tout le monde est prêt, le statut sera le booléen True.
Sinon, le statut sera le booléen False.
"""
relative_address = "/home/game/room/launch"
adresse = make_address(absolute_address, relative_address)
dataPost = {
'pseudo': self.pseudo,
'id_salle': self.id_salle,
'est_chef': self.est_chef
}
# -- on requete pour savoir si tout le monde est pret dans la salle
res = requests.get(adresse, data=json.dumps(dataPost))
# -- si on récupère un "tout le monde est pret", on lance la partie
if res.status_code == 200:
Resultat = self.update_resultat(
True,
"Tout le monde est prêt dans la salle. La partie va se lancer."
)
else:
Resultat = self.update_resultat(
False,
"En attente que tous les participants soient prêts pour lancer la partie."
)
return Resultat
def aff_classement_P4(self):
"""
Fonction qui gère la demande d'affichage du classement du puissance 4 de l'utilisateur.
Returns
------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette commande ainsi que le message associé
Si le traitement de la demande d'affichage est faite sans accroc, le statut sera le booléen True
et le dictionnaire renverra aussi le classement du puissance 4 mondial et celui entre amis.
Sinon, le statut sera le booléen False, avec la raison de cette echec dans le message associé.
"""
relative_address = "/home/main/profil/classment/jeu"
adresse = make_address(absolute_address, relative_address)
# -- connexion à l'API
dataPost = {"nom_jeu": "P4", "pseudo": self.pseudo}
res = requests.get(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True)
Resultat["classement_jeu"] = res.json()["classement_jeu"]
Resultat["classement_jeu_amis"] = res.json()["classement_jeu_amis"]
elif res.status_code == 404:
Resultat = self.update_resultat(False, "erreur, l'api n'a pas été trouvée")
elif res.status_code == 500:
Resultat = self.update_resultat(False, "erreur dans le code de l'api")
else:
Resultat = self.update_resultat(False, "erreur non prévue : " + str(res.status_code))
return Resultat
def is_salle_anonyme_available(self):
"""
Procédure qui vérifie si il existe une salle ouverte aux anonymes est encore disponible.
Returns
-------
Resultat : dict
Dictionnaire contenant la réussite ou non de cette vérification et le message associé.
Si il existe une salle est qu'il y a encore de la place : le statut sera le booléen True.
Si il existe de telles salle mais quelles sont pleinnes : le statut sera le booléen False
Si une erreur a lieu pendant la procédure, le statut sera false et le message associé determinera
la raison de l'erreur
"""
relative_address = "/home/game/room/anonyme"
adresse = make_address(absolute_address, relative_address)
dataPost = {'pseudo': self.pseudo, 'game': self.jeu}
res = requests.get(adresse, data=json.dumps(dataPost))
if res.status_code == 200: #une salle anonyme est dispo
Resultat = self.update_resultat(True)
Resultat["id_salle"] = res.json()['id_salle']
elif res.status_code == 404:
Resultat = self.update_resultat(False)
elif res.status_code == 500:
Resultat = self.update_resultat(False,
"erreur dans le code de l'api")
else:
Resultat = self.update_resultat(
False, "erreur non prévue : " + str(res.status_code))
return Resultat
def get_liste_couleurs_dispos(self):
"""
Fonction qui gère l'affichage de la liste des couleurs disponibles.
Returns
-------
Resultat: dict
Dictionnaire contenant la réussite ou non d'affichage de cette liste et le message associé
Si l'affichage a bien lieu, le statut sera le booléen True et le dictionnaire renverra aussi
la liste des couleurs disponibles.
Sinon, le statut sera le booléen False, la cause justifiée dans le message associé peut être:
une erreur quelconque ou le fait que l'utilisateur soit seul dans la salle.
"""
relative_address = "/home/game/room/colors"
adresse = make_address(absolute_address, relative_address)
dataPost = {'id_salle': self.id_salle}
res = requests.get(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True)
Resultat["liste_couleurs_dispos"] = res.json(
)["liste_couleurs_dispos"]
elif res.status_code == 403:
Resultat = self.update_resultat(
False,
"Vous ne pouvez pas être pret car vous êtes seuls dans la salle. Il faut être au moins 2."
)
else:
Resultat = self.update_resultat(
False, "erreur ndas PlayerClass.get_liste_couleurs_dispos")
return Resultat
def quitter_salle(self):
"""
Fonction qui permet à un utilisateur de quitter une salle.
Returns
-------
Resultat : dict
Dictionnaire contenant la réussite ou non d'abandon de la salle et le message associé
Si l'abandon a bien eu lieu, le statut sera le booléen True.
Si l'abandon ne peut avoir lieu, car l'utilisateur est chef de salle par exemple,
le statut sera le booléen False et la cause sera justifée dans le message associé
"""
relative_address = "/home/game/room"
adresse = make_address(absolute_address, relative_address)
dataPost = {
"pseudo": self.pseudo,
"id_salle": self.id_salle,
"est_chef_salle": self.est_chef
}
res = requests.delete(adresse, data=json.dumps(dataPost))
if res.status_code == 401:
Resultat = self.update_resultat(
False,
"Vous êtes le chef de la salle! Vous ne pouvez pas la quitter tant qu'un autre utilisateur s'y trouve encore. Un capitaine quitte toujours son navire en dernier n'est-ce pas?"
)
elif res.status_code == 200:
Resultat = self.update_resultat(
True, f"Vous avez quitté la salle {self.id_salle}")
return Resultat
def voir_membres_salle(self):
"""
Fonction qui permet de renvoyer les memebres présents dans une même salle.
Returns
-------
Resultats : dict
Dictionnaire contenant la réussite ou non d'affichage des membres et le message associé.
Si l'affichage a bien lieu, le statut sera le booléen True et le dictionnaire renverra aussi
la liste des membres de la salle.
Sinon, le statut sera le booléen False et le message associé justifiera l'erreur.
"""
relative_address = "/home/game/room"
adresse = make_address(absolute_address, relative_address)
dataPost = {'id_salle': self.id_salle}
res = requests.get(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True)
Resultat["liste_membres"] = res.json()["liste_membres"]
else:
Resultat = self.update_resultat(
False, "erreur dans PlayerClass.voir_membres_salle")
return Resultat
def modifier_mdp(self,old_mdp,new_mdp1,new_mdp2):
"""
Fonction qui gère la modification du mot de passe d'un utilisateur
Parameters
------
old_mdp: str
Ancien mot de passe que l'utilisateur souhaite modifier.
new_mdp1: str
Mot de passe qu'il veut avoir
new_mdp2: str
confirmation de ce mot de passe
Returns
------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette commande ainsi que le message associé
Si la modification de mot de passe est faite sans accrocs, le statut sera le booléen True.
A l'inverse, le statut sera le booléen False si les erreurs suivantes, que précisera le message associé, arrivent :
-Les deux nouveaux mots de passes ne correspondent pas.
-L'ancien mot de passe fournit ne correspond pas.
-Des erreurs quelconques ont lieu.
"""
relative_address = "/home/main/profil/user/password"
adresse = make_address(absolute_address, relative_address)
if new_mdp1 != new_mdp2:
Resultat = self.update_resultat(False, "Les deux nouveaux mots de passes ne correspondent pas.")
return Resultat
if new_mdp1 == "":
Resultat = self.update_resultat(False, "Veuillez fournir un nouveau mot de passe svp.")
return Resultat
if not anti_SQl_injection(new_mdp1):
Resultat = self.update_resultat(False, "Pour des raisons de sécurité, votre demande ne peut aboutir.")
return Resultat
# if not is_mdp_legal(new_mdp1):
# return self.echec_modif_mdp()
dataPost = {'pseudo': self.pseudo, 'old_password': old_mdp, 'new_password': new_mdp1}
res = requests.put(adresse, data=json.dumps(dataPost))
if res.status_code == 401:
Resultat = self.update_resultat(False, "Le mot de passe fournit ne correspond pas.")
elif res.status_code == 200:
Resultat = self.update_resultat(True, "Le mot de passe a bien été modifié.")
elif res.status_code == 404:
Resultat = self.update_resultat(False, "erreur, l'api n'a pas été trouvée")
elif res.status_code == 500:
Resultat = self.update_resultat(False, "erreur dans le code de l'api")
else:
Resultat = self.update_resultat(False, "erreur non prévue : " + str(res.status_code))
return Resultat
def rejoindre_salle(self, id_salle):
"""
Fonction qui gère le fait qu'un utilisateur rejoint une salle d'un amis.
Parameters
-------
id_salle: int
identifiant de la salle que veut rejoindre l'utilisateur.
Returns
-------
Resultat : dict
Dictionnaire contenant la réussite ou non que l'utilisateur ait rejoint la partie , et le message associé.
Si l'utilisateur a réussi a rejoindre la salle, le statut sera le booléen True et
le dictionnaire renverra aussi l'identifiant de la salle.
Si l'utilisateur ne peut rejoindre la salle le statut sera le booléen False et le message associé
justifiera la cause pouvant être : Une erreur quelconque, le fait que la partie soit déja pleine
ou bien que cette partie n'existe pas.
"""
relative_address = "/home/game/room"
adresse = make_address(absolute_address, relative_address)
dataPost = {
'pseudo': self.pseudo,
'id_salle': id_salle,
'jeu': self.jeu
}
res = requests.put(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(
True, f"Vous avez bien été ajouté à la salle {id_salle}.")
Resultat["id_salle"] = id_salle
elif res.status_code == 401:
Resultat = self.update_resultat(
False,
f"Vous ne pouvez pas rejoindre la salle {id_salle} car elle est déjà pleine."
)
elif res.status_code == 404:
Resultat = self.update_resultat(False,
"La salle demandée n'existe pas.")
elif res.status_code == 500:
Resultat = self.update_resultat(False,
"erreur dans le code de l'api")
else:
Resultat = self.update_resultat(
False, "erreur non prévue : " + str(res.status_code))
return Resultat
def creer_salle(self):
"""
Fonction qui assure la création d'une salle pour jouer un un jeu.
Returns
------
Resultat : dict
Dictionnaire contenant la réussite ou non de la création d'une salle et le message associé
Si la partie a bien été créée, le statut sera le booléen True, deux possiblités permettent cette option :
1- création d'une partie entre amis
2- création d'une parite entre anonyme.
le dictionnaire renverra aussi l'identifiant de la salle.
Si la partie n'a pas été crée due à differentes erreurs, le statut sera le booléen False
"""
relative_address = "/home/game/room"
adresse = make_address(absolute_address, relative_address)
dataPost = {
'pseudo_chef_salle': self.pseudo,
'game': self.jeu,
"ami_anonyme": self.ami_anonyme
}
res = requests.post(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
if self.ami_anonyme == "ami":
Resultat = self.update_resultat(
True,
f"Une salle (numéro {res.json()['id_salle']}) vient d'être créée. Vos amis peuvent la rejoindre via son numéro."
)
else:
Resultat = self.update_resultat(True)
Resultat["id_salle"] = res.json()['id_salle']
elif res.status_code == 404:
Resultat = self.update_resultat(
False, "erreur, l'api n'a pas été trouvée")
elif res.status_code == 500:
Resultat = self.update_resultat(False,
"erreur dans le code de l'api")
else:
Resultat = self.update_resultat(
False, "erreur non prévue : " + str(res.status_code))
return Resultat
def ajout_ami(self,pseudo_ami):
"""
Foction qui gère l'ajout d'un autre utilisateur dans la liste d'amis.
Parameters
-----
pseudo_ami: str
Pseudo de l'utilisateur à ajouter en ami.
Returns
-----
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette commande ainsi que le message associé
Si l'ajout s'est fait sans accrocs, le statut sera le booléen True.
A l'inverse, le statut sera le booléen False si les erreurs suivantes, que précisera le message associé, arrivent :
-Le pseudo n'existe pas.
-Le lien d'amitié existe déja.
-Des erreurs quelconques ont lieu.
"""
relative_address = "/home/main/profil/friends"
adresse = make_address(absolute_address, relative_address)
if pseudo_ami == self.pseudo:
Resultat = self.update_resultat(False, "Vous ne pouvez pas vous ajouter vous même comme ami.")
return Resultat
dataPost = {'pseudo': self.pseudo, 'pseudo_ami': pseudo_ami}
# -- connexion à l'API
res = requests.post(adresse, data=json.dumps(dataPost))
if res.status_code == 404:
Resultat = self.update_resultat(False, f"Le pseudo a ajouter à votre liste d'ami ({pseudo_ami}) n'existe pas.")
elif res.status_code == 208:
Resultat = self.update_resultat(False, f"Le lien d'amitié avec {pseudo_ami} existe déjà.")
elif res.status_code == 200:
Resultat = self.update_resultat(True, f"Votre nouvel ami ({pseudo_ami}) a bien été ajouté à votre liste d'amis.")
elif res.status_code == 500:
Resultat = self.update_resultat(False, "erreur dans le code de l'api")
else:
Resultat = self.update_resultat(False, "erreur non prévue : " + str(res.status_code))
return Resultat
def modifier_pseudo(self,new_pseudo):
"""
Fonction qui gère la modification du pseudo d'un utilisateur
Parameters
------
new_pseudo: str
Nouveau pseudo que l'utilisateur veut avoir
Returns
------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette commande ainsi que le message associé
Si la modification du pseudo est faite sans accrocs, le statut sera le booléen True.
A l'inverse, le statut sera le booléen False si les erreurs suivantes, que précisera le message associé, arrivent :
-Le pseudo demandé est déjà utilisé.
-Le nouveau pseudo est identique à l'ancien.
-Des erreurs quelconques ont lieu.
"""
relative_address = "/home/main/profil/user/pseudo"
adresse = make_address(absolute_address, relative_address)
if new_pseudo == self.pseudo:
Resultat = self.update_resultat(False, "Le nouveau pseudo est identique à l'ancien.")
return Resultat
dataPost = {'old_pseudo': self.pseudo, 'new_pseudo': new_pseudo}
res = requests.put(adresse, data=json.dumps(dataPost))
if res.status_code == 409:
Resultat = self.update_resultat(False, "Le pseudo demandé est déjà utilisé.")
elif res.status_code == 200:
self.pseudo = new_pseudo
Resultat = self.update_resultat(True, "Le pseudo a été mis à jour.")
elif res.status_code == 404:
Resultat = self.update_resultat(False, "erreur, l'api n'a pas été trouvée")
elif res.status_code == 500:
Resultat = self.update_resultat(False, "erreur dans le code de l'api")
else:
Resultat = self.update_resultat(False, "erreur non prévue : " + str(res.status_code))
return Resultat
def rejoindre_salle_anonyme(self):
"""
Fonction qui gère le fait qu'un utilisateur rejoint une salle d'anonyme.
Returns
-------
Resultat : dict
Dictionnaire contenant la réussite ou non que l'utilisateur ait rejoint une partie , et le message associé.
Si l'utilisateur a réussi a rejoindre une salle, le statut sera le booléen True.
Si l'utilisateur ne peut rejoindre la salle le statut sera le booléen False et le message associé
justifiera la cause pouvant être : Une erreur quelconque, le fait que la partie soit déja pleine
ou qu'aucune salle ne soit disponible.
"""
relative_address = "/home/game/room/anonyme"
adresse = make_address(absolute_address, relative_address)
res = requests.put(adresse,
data=json.dumps(dataPost)) #on recupere le id_salle
dataPost = {
'pseudo': self.pseudo,
'id_salle': res["id_salle"],
'jeu': self.jeu
}
if res.status_code == 200:
Resultat = self.update_resultat(
True,
f"Vous avez bien été ajouté à la salle anonyme {id_salle}.")
Resultat["id_salle"] = id_salle
elif res.status_code == 401:
Resultat = self.update_resultat(
False, f"La salle anonyme {id_salle} est pleine") #surbooking
elif res.status_code == 404:
Resultat = self.update_resultat(
False, "Aucune salle anonyme de disponible")
elif res.status_code == 500:
Resultat = self.update_resultat(False,
"erreur dans le code de l'api")
else:
Resultat = self.update_resultat(
False, "erreur non prévue : " + str(res.status_code))
return Resultat
def choix_couleur(self, couleur_choisie):
"""
Fonction qui gère le choix de la couleur séléctionnée par un utilisateur.
Parameters
------
couleur_choisie: str
Couleur choisie par l'utilisateur
Returns
------
Resultat: dict
Dictionnaire contenant la réussite ou non de cette sélection, et le message associé
Si la sélection a bien eu lieu, le statut sera le booléen True.
Sinon, le statut sera le booléen False, le message associé justifiera la cause, pouvant être :
une erreur quelconque ou le fait que la couleur ait été choisie par quelqu'un d'autre.
"""
relative_address = "/home/game/room/colors"
adresse = make_address(absolute_address, relative_address)
dataPost = {
'id_salle': self.id_salle,
'pseudo': self.pseudo,
'couleur': couleur_choisie
}
res = requests.post(adresse, data=json.dumps(dataPost))
if res.status_code == 409: #la couleur a été choisie entre temps
Resultat = self.update_resultat(
False,
"La couleur demandée a été choisie entre temps par un autre utilisateur. Veuillez réessayer svp."
)
elif res.status_code == 200:
Resultat = self.update_resultat(True)
else:
Resultat = self.update_resultat(
False, "erreur dans PlayerClass.choix_couleur")
return Resultat
def passer_tour(self):
"""
Fonction qui gère le passage de tour d'un utilisateur.
Returns
------
Resultat: dict
Dictionnaire contenant la réussite ou non de ce passage de tour et le message associé
Si l'action est bien éffectuée, le statut sera le booléen True.
Sinon, le statut sera le booléen False.
"""
relative_address = "/home/game/room/turns"
adresse = make_address(absolute_address, relative_address)
dataPost = {'pseudo': self.pseudo, 'id_salle': self.id_salle}
res = requests.put(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True, "Vous passez votre tour.")
else:
Resultat = self.update_resultat(False)
return Resultat
def gestion_fin_partie(self, self_win):
"""
Fonction qui gère la fin de la partie ou ce trouve l'utilisateur, i.e qui mais à jour ses statistiques personnelles
Parameters
------
self_win: bool
Parametre qui définit si l'utilisateur est le vainqueur de la partie.
Returns
-------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette commande ainsi que le message associé
Si les statistiques ont été mises à jour, le statut sera le booléen True.
Sinon, le statut sera le booléen False et le message associcé précisera la cause.
"""
#-- fonction qui nous retire de la table participation pour cette partie,
# qui update si on a gagné notre nb de parties gagnees dans la table score
# et qui update notre score (si la partie est anonyme)
relative_address = "/home/game/room/end"
adresse = make_address(absolute_address, relative_address)
dataPost = {
'pseudo': self.pseudo,
'id_partie': self.id_salle,
'jeu': self.jeu.lower(),
'win_bool': self_win,
"ami_anonyme": self.ami_anonyme
}
res = requests.put(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(
True, "Vos statistiques ont été mises à jour")
else:
Resultat = self.update_resultat(
False, "erreur dans PlayerClass.gestion_fin_partie")
return Resultat
def jouer_son_tour(self, action):
"""
Fonction qui gère la demande de jouer son tour, avec une action particuliere, pour un utilisateur
Parameters
------
action :
action en entrée, lancé de dé pour le jeu de l'oie et choix de colonne pour le P4.
Returns
-------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette commande ainsi que le message associé
Si la demande est bien traitée, le statut sera le booléen True.
Sinon, le statut sera le booléen False, le message associé en précisera la raison.
"""
relative_address = "/home/game/room/grid"
adresse = make_address(absolute_address, relative_address)
coup = {
'pseudo': self.pseudo,
'id_partie': self.id_salle,
'position': action['action'],
'jeu': self.jeu
}
res = requests.post(adresse, data=json.dumps(coup))
if res.status_code == 200:
Resultat = self.update_resultat(True, "Le coup a bien été joué.")
elif res.status_code == 403:
Resultat = self.update_resultat(False, res.json()["message"])
else:
Resultat = self.update_resultat(
False, "erreur dans PlayerClass.jouer_son_tour")
return Resultat
def acceder_stats_perso(self):
"""
Fonction qui gère la demande d'affichage des statistiques de l'utilisateur.
Returns
------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, d'execution de cette commande ainsi que le message associé
Si le traitement de la demande d'affichage est faite sans accroc, le statut sera le booléen True
et le dictionnaire renverra aussi ces statistiques.
Sinon, le statut sera le booléen False, avec la raison de cette echec dans le message associé.
"""
relative_address = "/home/main/profil/user/stat"
adresse = make_address(absolute_address, relative_address)
dataPost = {'pseudo': self.pseudo}
# -- connexion à l'API
res = requests.get(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
stat_perso = res.json()['Statistiques personnelles']
parties_g = stat_perso[0][1]
parties_j = stat_perso[0][0]
pourc_partie_g = 0
if parties_j != 0:
pourc_partie_g = parties_g / parties_j * 100
stat_perso[0].append("{} %".format(pourc_partie_g))
Resultat = self.update_resultat(True)
Resultat["stat_perso"] = stat_perso
elif res.status_code == 404:
Resultat = self.update_resultat(False, "erreur, l'api n'a pas été trouvée")
elif res.status_code == 500:
Resultat = self.update_resultat(False, "erreur dans le code de l'api")
else:
Resultat = self.update_resultat(False, "erreur non prévue : " + str(res.status_code))
return Resultat
def demander_tour(self):
"""
Fonction qui gère la demande de tour, ainsi l'interrogateur va savoir si c'est à lui de jouer ou non.
Returns
-------
Resultat: dict
Dictionnaire contenant la réponse, positive ou non, de cette demande, et le message associé.
Si c'est au tour de l'utilisateur et qu'il peut jouer, le statut sera le booléen True.
Deplus, le statut sera le booléen False si :
-C'est au tour du joueur, mais il ne peut jouer son tour.
-Ce n'est pas son tour.
-Il y a une erreur quelconque.
la cause sera justifiée dans le message associée
"""
relative_address = "/home/game/room/turns"
adresse = make_address(absolute_address, relative_address)
dataPost = {'pseudo': self.pseudo, 'id_salle': self.id_salle}
res = requests.get(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True, "C'est votre tour de jouer")
elif res.status_code == 403:
Resultat = self.update_resultat(
False,
"C'était votre tour de jouer mais vous deviez le passer.")
elif res.status_code == 449:
Resultat = self.update_resultat(
False, "Ce n'est pas votre tour de jouer")
else:
Resultat = self.update_resultat(
False, "erreur dans PlayerClass.demander_tour")
return Resultat
def creer_compte(self, identifiant, mdp, mdp2, pseudo):
"""
Fonction qui a pour but de créer un compte pour un nouvel utilisateur.
Parameters
------
identifiant : str
identifiant entré par le nouvel utilisateur.
mdp : str
Mot de passe entré par le nouvel utilisateur.
mdp2 : str
Confirmation du mot de passe entré par le nouvel utilisateur.
pseudo : str
Pseudo entré par le nouvel utilisateur.
Returns
------
Resultat: dict
Dictionnaire contenant la réussite ou non de création d'un utilisateur et le message associé
Si la création de compte c'est faite sans accroc, le statut sera le booléen True.
A l'inverse, le statut sera le booléen False si les erreurs suivantes, que précisera le message associé, arrivent :
-Les mot de passes ne correspondent pas.
-L'identifiant ou le mot de passe n'a pas été précisé.
-L'identifiant ou le pseudo est déjà utilisé.
-Des erreurs quelconques ont lieu.
"""
relative_address = "/home/users"
adresse = make_address(absolute_address, relative_address)
if mdp != mdp2:
Resultat = self.update_resultat(
False, "Les mot de passes ne correspondent pas.")
return Resultat
if identifiant == "" or mdp == "":
Resultat = self.update_resultat(
False, "L'identifiant ou le mot de passe n'a pas été précisé.")
return (Resultat)
if not anti_SQl_injection(identifiant) or not anti_SQl_injection(
mdp) or not anti_SQl_injection(pseudo):
Resultat = self.update_resultat(
False,
"Pour des raisons de sécurité, votre demande ne peut aboutir.")
return (Resultat)
if not is_mdp_legal(mdp):
Resultat = self.update_resultat(False)
return (Resultat)
hmdp = hacherMotDePasse(mdp)
# création du data pour le corps du post de l'api
dataPost = {
'username': identifiant,
"hpassword": hmdp,
"pseudo": pseudo
}
# -- connexion à l'API
res = requests.post(adresse, data=json.dumps(dataPost))
if res.status_code == 409:
if "User" in res.json()['message']:
Resultat = self.update_resultat(
False,
"L'identifiant est déjà utilisé par un autre membre.")
elif "Pseudo" in res.json()['message']:
Resultat = self.update_resultat(
False, "Le pseudo est déjà utilisé par un autre membre")
else:
Resultat = self.update_resultat(
False, "error in UserBase.creer_compte")
elif res.status_code == 404:
Resultat = self.update_resultat(
False, "erreur, l'api n'a pas été trouvée")
elif res.status_code == 500:
Resultat = self.update_resultat(False,
"erreur dans le code de l'api")
elif res.status_code == 200:
Resultat = self.update_resultat(
True,
"Compte créé avec succès. Veuillez vous authentifiez svp")
else:
Resultat = self.update_resultat(
False, "erreur non prévue : " + str(res.status_code))
return Resultat
def connexion(
self,
identifiant,
mdp,
):
"""
Fonction qui gère la connexion d'un utilisateur.
Parameters
------
identifiant : str
identifiant entré par l'utilisateur
mdp : str
mot de passe entré par l'utilisateur
Returns
-------
Resultat: dict
Dictionnaire contenant la réussite ou non de connexion d'un utilisateur et le message associé.
Si la connexion se fait sans accrocs, le statut sera le booléen True.
A l'inverse, le statut sera le booléen False si les erreurs, que précisera le message associé, arrivent:
-L'identifiant ou le mot de passe n'a pas été précisé.
-Identifiant ou mot de passe incorrect.
-L'utilisateur est déjà connecté.
-Des erreurs quelconques ont lieu.
"""
relative_address = "/home/connexion"
adresse = make_address(absolute_address, relative_address)
if identifiant == "" or mdp == "":
Resultat = self.update_resultat(
False, "L'identifiant ou le mot de passe n'a pas été précisé.")
return Resultat
if not anti_SQl_injection(identifiant) or not anti_SQl_injection(mdp):
Resultat = self.update_resultat(
False,
"Pour des raisons de sécurité, votre demande ne peut aboutir.")
return Resultat
# -- connexion à l'API
dataPost = {'username': identifiant, "password": mdp}
res = requests.get(adresse, data=json.dumps(dataPost))
if res.status_code == 200:
Resultat = self.update_resultat(True, "Connection réussie")
Resultat["pseudo"] = res.json()["pseudo"]
elif res.status_code == 404:
Resultat = self.update_resultat(
False, "erreur, l'api n'a pas été trouvée")
elif res.status_code == 500:
Resultat = self.update_resultat(False,
"erreur dans le code de l'api")
elif res.status_code == 401:
Resultat = self.update_resultat(
False, "Identifiant ou mot de passe incorrect.")
elif res.status_code == 403:
Resultat = self.update_resultat(False,
"L'utilisateur est déjà connecté")
else:
Resultat = self.update_resultat(
False, "erreur non prévue : " + str(res.status_code))
return Resultat
