¿Cómo automatizar creauperuser en django?

Question

Quiero ejecutar automáticamente migrate.py createsuperuser en django pero parece que no hay forma de establecer una contraseña predeterminada.

¿Cómo puedo obtener esto? Tiene que ser independiente en la base de datos django.

Answer 1

Puede escribir un script de python simple para manejar la automatización de la creación del superusuario. El modelo User es solo un modelo normal de Django, por lo que seguiría el proceso normal de escritura de un script de Django independiente. Ej:

import django 
django.setup() 

from django.contrib.auth.models import User 

u = User(username='unique_fellow') 
u.set_password('a_very_cryptic_password') 
u.is_superuser = True 
u.is_staff = True 
u.save() 

También puede pasar createsuperuser algunas opciones, a saber --noinput y --username, lo que permitirá crear automáticamente los nuevos super-usuarios, pero no sería capaz de iniciar sesión hasta que se establezca una contraseña para ellos.

Answer 2

muy fácil, escuche la señal syncdb de la publicación y lea las credenciales del superusuario desde un archivo de configuración y aplíquelo.

checkout django-bootup

https://github.com/un33k/django-bootup/blob/master/README

Answer 3

Aquí hay una versión sencilla de la secuencia de comandos para crear un superusuario:

echo "from django.contrib.auth.models import User; User.objects.create_superuser('admin', 'admin@example.com', 'pass')" | python manage.py shell 

EDITAR

Como se sugiere en los comentarios, las siguientes eliminaciones de comando y crea el superusuario lo que el comando siempre funciona para todas las construcciones:

echo "from django.contrib.auth.models import User; User.objects.filter(email='admin@example.com').delete(); User.objects.create_superuser('admin', 'admin@example.com', 'nimda')" | python manage.py shell 

Answer 4

Respuesta más votados:

• Elimina el usuario si existe y como señala @Groady en los comentarios, corre el riesgo de eliminar involuntariamente cualquier registro asociado mediante una eliminación en cascada.
• Comprueba la existencia del superusuario filtrándose por correo, de modo que si dos superusuarios tienen el mismo correo, Dios sabe cuál eliminará.
• Es engorroso actualizar los parámetros del script: nombre de usuario, contraseña y correo.
• No registra lo que hizo.

Una versión mejorada sería:

USER="admin" 
PASS="super_password" 
MAIL="admin@mail.com" 
script=" 
from django.contrib.auth.models import User; 

username = '$USER'; 
password = '$PASS'; 
email = '$MAIL'; 

if User.objects.filter(username=username).count()==0: 
    User.objects.create_superuser(username, email, password); 
    print('Superuser created.'); 
else: 
    print('Superuser creation skipped.'); 
" 
printf "$script" | python manage.py shell 

Answer 5

Este pequeño script en Python, podría crear un usuario normal o un superusuario

#!/usr/bin/env python 

import os 
import sys 
import argparse 
import random 
import string 
import django 


def main(arguments): 

    parser = argparse.ArgumentParser() 
    parser.add_argument('--username', dest='username', type=str) 
    parser.add_argument('--email', dest='email', type=str) 
    parser.add_argument('--settings', dest='settings', type=str) 
    parser.add_argument('--project_dir', dest='project_dir', type=str) 
    parser.add_argument('--password', dest='password', type=str, required=False) 
    parser.add_argument('--superuser', dest='superuser', action='store_true', required=False) 

    args = parser.parse_args() 

    sys.path.append(args.project_dir) 
    os.environ['DJANGO_SETTINGS_MODULE'] = args.settings 
    from django.contrib.auth.models import User 
    django.setup() 

    username = args.username 
    email = args.email 
    password = ''.join(random.sample(string.letters, 20)) if args.password is None else args.password 
    superuser = args.superuser 

    try: 
     user_obj = User.objects.get(username=args.username) 
     user_obj.set_password(password) 
     user_obj.save() 
    except User.DoesNotExist: 
    if superuser: 
      User.objects.create_superuser(username, email, password) 
    else: 
     User.objects.create_user(username, email, password) 

    print password 


if __name__ == '__main__': 
    sys.exit(main(sys.argv[1:])) 

--superuser & --password no son obligatorios.

Si --superuser no está definido, el usuario normal se creó Si --password no está definido, una contraseña aleatoria se generarán

Ex : 
     /var/www/vhosts/PROJECT/python27/bin/python /usr/local/sbin/manage_dja_superusertest.py --username USERNAME --email TEST@domain.tld --project_dir /var/www/vhosts/PROJECT/PROJECT/ --settings PROJECT.settings.env 

Answer 6

que estaba buscando una respuesta a esto mismo.Decidí crear un comando Django que se extiende el comando de base createsuperuser (GitHub):

from django.contrib.auth.management.commands import createsuperuser 
from django.core.management import CommandError 


class Command(createsuperuser.Command): 
    help = 'Crate a superuser, and allow password to be provided' 

    def add_arguments(self, parser): 
     super(Command, self).add_arguments(parser) 
     parser.add_argument(
      '--password', dest='password', default=None, 
      help='Specifies the password for the superuser.', 
     ) 

    def handle(self, *args, **options): 
     password = options.get('password') 
     username = options.get('username') 
     database = options.get('database') 

     if password and not username: 
      raise CommandError("--username is required if specifying --password") 

     super(Command, self).handle(*args, **options) 

     if password: 
      user = self.UserModel._default_manager.db_manager(database).get(username=username) 
      user.set_password(password) 
      user.save() 

Ejemplo uso:

./manage.py createsuperuser2 --username test1 --password 123321 --noinput --email 'blank@email.com' 

Esto tiene la ventaja de todavía que apoya el uso de comando predeterminado, mientras que también permite no - uso interactivo para especificar una contraseña.

Answer 7

utilizo './manage.py bombardear -c':

./manage.py shell -c "from django.contrib.auth.models import User; User.objects.create_superuser('admin', 'admin@example.com', 'adminpass')" 

esto no utiliza un eco adicional, esto tiene la ventaja de que se puede pasar a un recipiente cargador de muelle para su ejecución. Sin la necesidad de usar sh -c "..." que te hace pensar en escapar del infierno.

Y recuerde que primero viene nombre de usuario, que el correo electrónico.

Answer 8

Usé Tk421 un liner pero recibí un mensaje de error como: 1) Creo que estoy usando una versión posterior de Django (1.10) Manager isn't available; 'auth.User' has been swapped for 'users.User' 2) el orden de los parámetros para create_superuser era incorrecto.

Así que lo reemplazó con:

echo "from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.filter(email='admin@example.com', is_superuser=True).delete(); User.objects.create_superuser('admin', 'admin@example.com', 'nimda')" | python manage.py shell 

y lo que como muy contento con es que funciona en un despliegue heroku así:

heroku run echo "from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.filter(email='admin@example.com', is_superuser=True).delete(); User.objects.create_superuser('admin', 'admin@example.com', 'nimda')" | python manage.py shell 

Esto funciona muy bien en varias ocasiones. Lo estoy usando al comienzo de un proyecto, así que no se preocupe por las terribles eliminaciones en cascada que podrían ocurrir más adelante.

He vuelto a visitar después de algunos problemas con la ejecución de este local dentro() de la tela. lo que parece estar sucediendo es que el símbolo de la tubería significa que fue interpretado localmente en lugar de heroku. Para ordenar esto, envolví el comando entre comillas. Luego tuvo que usar comillas dobles triples para las cadenas de python dentro de las comillas simples de todo el comando python.

heroku run "echo 'from django.contrib.auth import get_user_model; User = get_user_model(); User.objects.filter(email="""admin@example.com""", is_superuser=True).delete(); User.objects.create_superuser("""admin""", """admin@example.com""", """nimda""")' | python manage.py shell" 

Answer 9

Esto es lo que armó para Heroku post_deploy y una predefinida app.json variables:

if [[ -n "$CREATE_SUPER_USER" ]]; then 
    echo "==> Creating super user" 
    cd /app/example_project/src 
    printf "from django.contrib.auth.models import User\nif not User.objects.exists(): User.objects.create_superuser(*'$CREATE_SUPER_USER'.split(':'))" | python /app/example_project/manage.py shell 
fi 

Con esto se puede tener una sola variable env:

CREATE_SUPER_USER=admin:admin@example.com:password 

me gusta el shell --command opción, pero no estoy seguro de cómo obtener el carácter de nueva línea en el script de comando. Sin la nueva línea, la expresión if da como resultado un error de sintaxis.