problème bloc verification sqlite3

a marqué ce sujet comme résolu.

bonjour je cherche a faire un système qui verifie si un nom d'utilisateur est dans la base de données (existe déjà) dans ce cas on exit, si ce dernier n'existe pas (c'est bon) on teste si le mdp choisit existe déjà et si c'est le cas on break, si les deux sont bons on autorise la création du profil. Mais comment faire ceci car après des recherches sur le web je ne suis qu'arrivé a des prototypes qui ne marchent pas vraiment. C'est ou il y a le pass pour le row in data qu'il faut faire tous les tests pour tous les profils de la base de données et si après avoir testé si le mdp et le username n'existent pas en passant dans tous les profils de ma base alors on ajoute le profil de l'utilisateur. Quelqu'un sait le faire ? encore merci et voici le code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import  sqlite3
import sys

if len(sys.argv) < 3:
    print('[Usage] python manager.py <username> <password>')
    sys.exit()

username = sys.argv[1]
password = sys.argv[2]

class register:

    def __init__(self):
        self.user = username
        self.password = password
        self.conn = sqlite3.connect('database.db')
        self.cursor = self.conn.cursor()

    def create_database(self):
        self.cursor.execute('CREATE TABLE IF NOT EXISTS users(username TEXT, password TEXT)')

    def dynamic_data_entry(self, username, password):
        self.cursor.execute('SELECT * FROM users')
        data = self.cursor.fetchall()
        for row in data:
            pass

    def main(self):
        self.create_database()
        self.dynamic_data_entry(self.user, self.password)


c = register()
c.main()

enfaite "

+0 -0

Salut,

Tout d'abord, je me demande pourquoi veux-tu faire en sorte que les mots de passe soient uniques ? Niveau conception, c'est pas top, ça restreint leur liberté de choix inutilement, le pseudo suffisant à les distinguer.

Ensuite, pour ton problème, cette requête devrait suffire à vérifier si le pseudo est déjà présent dans les enregistrements ou non (à tester) :

1
2
#Doit contenir 1 si le pseudo est déjà présent dans ton cas (car 1 occurrence), 0 sinon.
self.cursor.execute('SELECT COUNT(*) FROM users WHERE username = ?', (username, )))

Comme ça pas besoin d'itérer sur les données à chaque fois.

Mais après tu peux faire en sorte que le champ username soit UNIQUE, comme ça il ne pourra y avoir qu'une occurrence par valeur à chaque fois, sous peine de message d'erreur. Il suffira de capturer les erreurs lorsque tu essaieras d'enregistrer le pseudo et mdp dans la BDD et tu pourras donc dire à l'utilisateur d'entrer un pseudo différent si celui-ci est déjà pris.

+0 -0

du coup je devrias faire comment pour vérifier cela : parce que j'ai trouvé ce système mais sa marche pas si tu veux l'essayer regarde de toi même, il ne prend pas en compte le len(lock)

code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import sqlite3
import hashlib
import sys

conn = sqlite3.connect('database.db')
cursor = conn.cursor()

if len(sys.argv) < 3:
    print('[Usage] python inscription.py <username> <password>')
    sys.exit()

USERNAME = sys.argv[1]
PASSWORD = hashlib.md5(sys.argv[2].encode()).hexdigest()


class Register:
    def __init__(self):
        self.user = USERNAME
        self.password = PASSWORD
        self.conn = sqlite3.connect('users_database')
        self.cursor = self.conn.cursor()

    def checker(self, username, password):
        with self.conn:
            self.cursor.execute('CREATE TABLE IF NOT EXISTS users (username TEXT NOT NULL, password TEXT NOT NULL)')
            self.cursor.execute('SELECT COUNT(*) FROM users WHERE username=?', (username,))
            lock = str(self.cursor.fetchall())
            print(lock)
            if len(lock) > 1:
                print('Username already exists, please take another one...')
                sys.exit()
            else:
                data = (username, password)
                self.cursor.execute('INSERT INTO users VALUES(?, ?)', data)
                self.cursor.execute('SELECT * FROM users')
                c = self.cursor.fetchall()
                print(c)

    def main(self):
        self.checker(self.user, self.password)

if __name__ == '__main__':
    register = Register()
    register.main()
+0 -0

Alors,

Pourquoi convertis-tu le résultat de fetchall en chaîne ? C'est étrange.

Ensuite, tu vérifies si len(lock) > 1 or ce n'est pas bon, car s'il y a un utilisateur avec ce pseudo le résultat sera "1" et len("1") < 1 donc ça n'entrera pas dans la condition.

Tu devrais juste vérifier la valeur entière contenue dans le résultat de la requête, si c'est égal à 0 c'est bon, sinon non.

Encore une fois, je t'encourage à jeter un coup d’œil à la syntaxe SQL UNIQUE.

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte