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