Comment créer un utilisateur à partir du shell de django

Question

Lorsque je crée un utilisateur à partir de django-admin les mots de passe des utilisateurs sont cryptés. Mais lorsque je crée un utilisateur à partir du shell de django, le mot de passe de l'utilisateur est sauvegardé en texte clair. Exemple :

{
    "date_joined": "2013-08-28T04:22:56.322185",
    "email": "",
    "first_name": "",
    "id": 5,
    "is_active": true,
    "is_staff": false,
    "is_superuser": false,
    "last_login": "2013-08-28T04:22:56.322134",
    "last_name": "",
    "password": "pbkdf2_sha256$10000$iGKbck9CED0b$6hWrKYiMPNGKhcfPVGal2YP4LkuP3Qwem+2ydswWACk=",
    "resource_uri": "/api/v1/user/5/",
    "username": "user4"
},
{
    "date_joined": "2013-08-29T01:15:36.414887",
    "email": "test@ophio",
    "first_name": "",
    "id": 6,
    "is_active": true,
    "is_staff": true,
    "is_superuser": true,
    "last_login": "2013-08-29T01:15:36.414807",
    "last_name": "",
    "password": "123test",
    "resource_uri": "/api/v1/user/6/",
    "username": "test3"
} 

J'essaie de créer une api de type REST pour une simple application de blog : Je n'ai pas encore trouvé de solution à ce problème, mais j'ai trouvé une solution à ce problème. Je ne sais pas comment faire pour annuler ce comportement.

Answer 1

Vous ne devez pas créer l'utilisateur par le biais de la procédure normale User(...) la syntaxe, comme d'autres l'ont suggéré. Vous devez toujours utiliser User.objects.create_user() qui se charge de définir correctement le mot de passe.

user@host> manage.py shell
>>> from django.contrib.auth.models import User
>>> user=User.objects.create_user('foo', password='bar')
>>> user.is_superuser=True
>>> user.is_staff=True
>>> user.save()

Answer 2

La façon la plus rapide de créer un super utilisateur pour django est de taper dans le shell :

python manage.py createsuperuser

Answer 3

Pour automatiser le script, vous pouvez utiliser la fonction pipe pour exécuter la liste de commandes sans avoir à la taper à chaque fois.

### content of "create_user.py" file
from django.contrib.auth import get_user_model

# see ref. below
UserModel = get_user_model()

if not UserModel.objects.filter(username='foo').exists():
    user=UserModel.objects.create_user('foo', password='bar')
    user.is_superuser=True
    user.is_staff=True
    user.save()

Réf : get_user_model()

N'oubliez pas d'activer VirtualEnv en premier lieu, puis exécutez la commande ci-dessous (pour Linux) :

cat create_user.py | python manage.py shell

Si vous utilisez une fenêtre, remplacez le chat avec la commande type commande

type create_user.py | python manage.py shell

OU pour Linux et Windows

# if the script is not in the same path as manage.py, then you must 
#    specify the absolute path of the "create_user.py" 
python manage.py shell < create_user.py

Chute d'eau : n'incluez pas de lignes vides dans les blocs indentés, pensez-y comme si vous colliez votre code dans le REPL. Si vous avez des lignes vides, cela ne fonctionnera pas.

Answer 4

Réponse pour ceux qui utilisent django 1.9 ou plus depuis from django.contrib.auth.models import User a été déprécié (peut-être même avant), mais certainement à partir de la version 1.9.

Au lieu de cela, faites : en bash :

python manage.py shell

Dans le shell python pour créer un utilisateur avec un mot de passe :

from django.apps import apps
User = apps.get_model('user', 'User')
me = User.objects.create(first_name='john', email='johnsemail@email.com') # other_info='other_info', etc.
me.set_password('WhateverIwant')  # this will be saved hashed and encrypted
me.save()

Si vous venez d'une API, vous devriez probablement appliquer un formulaire en tant que tel :

import json
User = get_model('User')
class UserEditForm(BaseModelForm):
        """This allows for validity checking..."""

        class Meta:
            model = User
            fields = [
                'first_name', 'password', 'last_name',
                'dob', # etc...
            ]
# collect the data from the API:
post_data = request.POST.dict()
data = {
'first_name': post_data['firstName'],
'last_name': post_data['firstName'],
'password': post_data['password'], etc.
}
dudette = User()  # (this is for create if its edit you can get the User by pk with User.objects.get(pk=kwargs.pk))
form = UserEditForm(data, request.FILES, instance=dudette)
if form.is_valid():
    dudette = form.save()
else:
    dudette = {'success': False, 'message': unicode(form.errors)}
return json.dumps(dudette.json())  # assumes you have a json serializer on the model called def json(self):

Answer 5

Vous utilisez user.set_password pour définir des mots de passe dans le shell de django. Je ne suis même pas sûr que le fait de définir directement le mot de passe via user.password fonctionnerait même, puisque Django s'attend à un hachage du mot de passe.

En password ne stocke pas les mots de passe ; il les stocke en tant que <algorithm>$<iterations>$<salt>$<hash> Il n'y a donc pas d'autre moyen de vérifier un mot de passe que de calculer le hachage et de le comparer. Je doute que l'utilisateur ait réellement un mot de passe dont le hachage calculé se trouve dans le fichier <algorithm>$<iterations>$<salt>$<hash> forme.

Si vous obtenez le json avec toutes les informations nécessaires pour créer l'utilisateur, vous pourriez simplement faire

User.objects.create_user(**data)

en supposant que le json passé s'appelle data.

Remarque : une erreur se produira si vous avez des éléments supplémentaires ou manquants dans la rubrique data .

Si vous souhaitez vraiment modifier ce comportement, vous pouvez faire ce qui suit

def override_setattr(self,name,value):
    if name == 'password':
        self.set_password(value)
    else:
        super().__setattr__(self,name,value) #or however super should be used for your version

User.__setattr__ = override_setattr

Je n'ai pas testé cette solution, mais elle devrait fonctionner. A utiliser à vos risques et périls.