Como carregar o acessório SQL no Django para o modelo de usuário?

Question

Alguém sabe como carregar dados iniciais para auth.user usando acessórios SQL? Para meus modelos, acabei de ter um arquivo <ModenName> .SQL em uma pasta chamada SQL que o SyncDB faz seu trabalho lindamente. Mas não tenho idéia de como fazê -lo para o modelo Auth.User. Eu pesquisei no Google, mas sem sucesso.

Desde já, obrigado,

Aldo

Answer 1

Obrigado pelas suas respostas. Encontrei a solução que funciona para mim, e por coincidência foi uma das sugestões de Brian. Aqui está:

FIRS I desconectei o sinal que criou o super usuário após o SyncDB, pois tenho meu super usuário no meu acessório 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")

Então eu criei um sinal a ser chamado após o SyncDB:

<MyProject>/<MyApp>/gerenciamento/__ 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")

E no meu Settings.py Adicionei Fixtures_File com o caminho para o meu arquivo .SQL com o dump SQL.

Uma coisa que ainda não encontrei é como disparar esse sinal somente depois que as tabelas são criadas, e nem toda vez que o SyncDB é demitido. Uma solução temporária para isso é usar inserção ignorada no meu comando sql.

Eu sei que esta solução está longe de ser perfeita, e os críticos/melhorias/opiniões são muito bem -vindos!

Cumprimentos,

Aldo

Answer 2

Para acessórios SQL, você teria que inserir especificamente declarações para o auth mesas. Você pode encontrar o esquema das tabelas de autenticação com o comando python manage.py sql auth.

A maneira muito mais fácil e independente do banco de dados (a menos que você tenha alguma mágica SQL adicional que você deseja executar) é apenas fazer um JSON ou YAML acessório Arquivo no diretório de acessórios do seu aplicativo com dados como este:

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

Você pode gerar uma senha de hash rapidamente em um shell django

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

Isso será carregado sempre que você correr syncdb.

Answer 3

Você está procurando loaddata:

manage.py loadata path/to/your/fixtureFile

Mas acho que o comando só pode lidar com arquivos no formato XML, YAML, Python ou JSON (Veja aqui). Para criar arquivos tão apropriados, dê uma olhada no dumpdata método.

Answer 4

Há um truque para isso: (Testado no Django 1.3.1)

Solução:

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

Da próxima vez que você correr python manage.py syncdb, O Django carregará o equipamento de autenticação automaticamente.

Explicação:

1. Basta fazer um aplicativo vazio para segurar a pasta de acessórios. Deixe __init__py, models.py e views.py para que o Django o reconheça como um aplicativo e não apenas uma pasta.
2. Faça a pasta de acessórios no aplicativo.
3. python manage.py dumpdata auth despejará os dados "Auth" no banco de dados com todos os grupos e informações dos usuários. O restante do comando simplesmente redireciona a saída para um arquivo chamado "Initial_data.json", que é o que o Django procura quando você executa "Syncdb".
4. Basta incluir auth_fix em Installed_apps Inside Settings.py.

Este exemplo mostra como fazê -lo no JSON, mas você pode basicamente usar o formato de sua escolha.

Answer 5

Uma opção é importar seu Auth.User SQL manualmente e posteriormente despejá -lo em um acessório Django padrão (nomei -lo inicial_data se desejar o SyncDB para encontrá -lo). Geralmente, você pode colocar esse arquivo nos acessórios de qualquer aplicativo DIR, pois os dados fixos serão todos digitados com o app_label adequado. Ou você pode criar um aplicativo vazio/fictício e colocá -lo lá.

Outra opção é substituir o comando syncdb e aplicar o acessório de uma maneira como você achar adequado.

Concordo com Felix que não há gancho natural não trivial em Django para preencher aplicativos de contribonismo com SQL.

Answer 6

Se você estiver fazendo migrações de banco de dados com o sul, a criação de usuários é muito simples.

Primeiro, crie uma migração nua de dados. Ele precisa ser incluído em algum aplicativo. Se você tem um aplicativo comum onde você coloca código compartilhado, essa seria uma boa escolha. Se você possui um aplicativo no qual concentra o código relacionado ao usuário, isso seria ainda melhor.

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

O código de migração pertinente pode parecer algo assim:

# 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()

Em seguida, basta executar a migração e os usuários de autenticação devem ser inseridos.

$ python manage.py migrate <some app name>

Answer 7

Eu simplesmente adicionei instruções SQL ao arquivo SQL personalizado para outro modelo. Eu escolhi meu modelo de funcionário porque depende de auth_user. O SQL personalizado que escrevi na verdade lê do meu aplicativo herdado e extrai as informações do usuário e usa substituir em vez de inserir (estou usando o MySQL) para que eu possa executá -lo sempre que quiser. E eu coloquei isso substituindo ... selecione a instrução em um procedimento para que seja fácil de executar manualmente ou programado com Cron.