¿Cómo cargar un dispositivo SQL en Django para el modelo de usuario?

Question

¿Alguien sabe cómo cargar datos iniciales para auth.User usando accesorios SQL?Para mis modelos, acabo de tener un archivo <modelname>.sql en una carpeta llamada sql que syncdb hace su trabajo a la perfección.Pero no tengo idea de cómo hacerlo para el modelo auth.User.Lo busqué en Google, pero sin éxito.

Gracias de antemano,

aldo

Answer 1

Gracias por sus respuestas. He encontrado la solución que funcione para mí, y por coincidencia era uno de sugerencia de Brian. Aquí está:

Firs He desconectado la señal que creó el Super Usuario después syncdb, porque tengo mi súper usuario en mi accesorio auth_user:

models.py

from django.db.models import signals
from django.contrib.auth.management import create_superuser
from django.contrib.auth import models as auth_app


signals.post_syncdb.disconnect(
    create_superuser,
    sender=auth_app,
    dispatch_uid = "django.contrib.auth.management.create_superuser")

A continuación, creé una señal a ser llamado después de syncdb:

/ / gestión / __ __ init. Py

"""
Loads fixtures for files in sql/<modelname>.sql
"""
from django.db.models import get_models, signals
from django.conf import settings 
import <myproject>.<myapp>.models as auth_app

def load_fixtures(app, **kwargs):
    import MySQLdb
    db=MySQLdb.connect(host=settings.DATABASE_HOST or "localhost", \
       user=settings.DATABASE_USER,
    passwd=settings.DATABASE_PASSWORD, port=int(settings.DATABASE_PORT or 3306))

    cursor = db.cursor()

    try:
        print "Loading fixtures to %s from file %s." % (settings.DATABASE_NAME, \
            settings.FIXTURES_FILE)
        f = open(settings.FIXTURES_FILE, 'r')
        cursor.execute("use %s;" % settings.DATABASE_NAME)
        for line in f:
            if line.startswith("INSERT"):
                try:
                    cursor.execute(line)
                except Exception, strerror:
                    print "Error on loading fixture:"
                    print "-- ", strerror
                    print "-- ", line

        print "Fixtures loaded"

    except AttributeError:
        print "FIXTURES_FILE not found in settings. Please set the FIXTURES_FILE in \
            your settings.py" 

    cursor.close()
    db.commit()
    db.close()

signals.post_syncdb.connect(load_fixtures, sender=auth_app, \
    dispatch_uid = "<myproject>.<myapp>.management.load_fixtures")

Y en mi settings.py añadí FIXTURES_FILE con la ruta a mi archivo .sql con el volcado SQL.

Una cosa que todavía no he encontrado es cómo disparar esta señal sólo después de que se crean las tablas, y no cada vez que se dispara syncdb. Un trabajo temporal alrededor de esto es el uso INSERT IGNORE INTO en mi comando SQL.

Sé que esta solución está lejos de ser perfecto, y críticos / mejoras / opiniones son muy bienvenidos!

Saludos,

Aldo

Answer 2

Para los artefactos de SQL, que tendría que tener específicamente instrucciones de inserción para las tablas auth. Usted puede encontrar el esquema de las tablas de autenticación con el python manage.py sql auth comandos.

La forma más fácil y base de datos independiente (a menos que tenga un poco de magia de SQL adicional que desee ejecutar), es simplemente hacer una JSON o YAML archivo de datos en el directorio accesorios de su aplicación con datos como este:

- model: auth.user
  pk: 100000
  fields:
    first_name: Admin
    last_name: User
    username: admin
    password: "<a hashed password>"

Puede generar un hash de la contraseña rápidamente en una cáscara de django

>>> from django.contrib.auth.models import User
>>> u = User()
>>> u.set_password('newpass')
>>> u.password
'sha1$e2fd5$96edae9adc8870fd87a65c051e7fdace6226b5a8'

Esto se cargan cada vez que se ejecuta syncdb.

Answer 3

loaddata :

manage.py loadata path/to/your/fixtureFile

Sin embargo, creo que el comando sólo puede ocuparse de archivos en XML, YAML, Python o formato JSON ( ver aquí ). Para crear este tipo de archivos apropiados, echar un vistazo a la método dumpdata .

Answer 4

Hay un truco para esto: (probado en Django 1.3.1)

Solución:

1. python manage.py startapp auth_fix
2. mkdir auth_fix/fixtures
3. python manage.py dumpdata auth > auth_fixtures/fixtures/initial_data.json
4. Include auth_fix in INSTALLED_APPS inside settings.py

La próxima vez que ejecute python manage.py syncdb, Django cargar el dispositivo de autenticación automáticamente.

Explicación:

1. Sólo hacer una aplicación vacía para mantener la carpeta accesorios. Deja __init__py, models.py y views.py en ella para que Django lo reconoce como una aplicación y no sólo una carpeta.
2. Hacer la carpeta accesorios en la aplicación.
3. python manage.py dumpdata auth va a volcar los datos de autenticación "" en la base de datos con todos los grupos y usuarios de la información. El resto de la orden simplemente redirige la salida en un archivo llamado "initial_data.json", que es la que Django busca cuando se ejecuta "syncdb".
4. Sólo incluir auth_fix en el interior INSTALLED_APPS settings.py.

Este ejemplo muestra cómo hacerlo en JSON, pero básicamente se puede utilizar el formato de su elección.

Answer 5

Una opción es importar su auth.user SQL manualmente y posteriormente volcar a un accesorio de Django estándar (nombre que initial_data si quieres syncdb para encontrarlo). En general, usted puede poner este archivo en accesorios de cualquier aplicación dir ya que los datos fixtured todos serán codificados con el app_label adecuada. O puede crear una aplicación vacía / maniquí y colocarlo allí.

Otra opción es reemplazar el comando syncdb y aplicar el dispositivo de una manera como mejor le parezca.

Estoy de acuerdo con Felix que no hay gancho natural no trivial en Django para poblar aplicaciones contrib con SQL.

Answer 6

Si le sucede a estar haciendo migraciones de bases de datos con el sur, la creación de usuarios es muy simple.

En primer lugar, crear una migración de datos al descubierto. Tiene que ser incluido en alguna aplicación. Si usted tiene una aplicación común donde se colocan código compartido, que sería una buena opción. Si usted tiene una aplicación en la que se concentra código relacionada con el usuario, que sería aún mejor.

$ python manage.py datamigration <some app name> add_users

El código de migración pertinente podría ser algo como esto:

# encoding: utf-8
import datetime
from south.db import db
from south.v2 import DataMigration
from django.db import models
from django.contrib.auth.models import User

class Migration(DataMigration):

    users = [
        {
            'username': 'nancy',
            'email': 'nancy@example.com',
            'password': 'nancypassword',
            'staff': True,
            'superuser': True
        },
        {
            'username': 'joe',
            'email': '',
            'password': 'joepassword',
            'staff': True,
            'superuser': False
        },
        {
            'username': 'susan',
            'email': 'susan@example.com',
            'password': 'susanpassword',
            'staff': False,
            'superuser': False
        }
    ]

    def forwards(self, orm):
        """
        Insert User objects
        """
        for i in Migration.users:
            u = User.objects.create_user(i['username'],  i['email'], i['password'])
            u.is_staff = i['staff']
            u.is_superuser = i['superuser']
            u.save()

    def backwards(self, orm):
        """
        Delete only these users
        """
        for i in Migration.users:
            User.objects.filter(username=i['username']).delete()

A continuación, sólo tiene que ejecutar la migración y los usuarios de autenticación deben insertarse.

$ python manage.py migrate <some app name>

Answer 7

Simplemente agregué declaraciones SQL en el archivo SQL personalizado para otro modelo.Elegí mi modelo de Empleado porque depende de auth_user.El SQL personalizado que escribí en realidad lee desde mi aplicación heredada y extrae información del usuario de ella, y usa REPLACE en lugar de INSERT (estoy usando MySQL) para poder ejecutarlo cuando quiera.Y puse esa declaración REPLACE...SELECT en un procedimiento para que sea fácil de ejecutar manualmente o programar con cron.