Comment charger un appareil SQL dans le modèle Django for User?

Personne ne sait comment charger des données initiales pour l'auth.L'utilisateur à l'aide de sql montages?
Pour mes modèles, je viens d'avoir un < modelname >.sql fichier dans un dossier nommé sql qui syncdb t-il son travail à merveille. Mais je n'ai aucune idée de comment le faire pour l'auth.Modèle utilisateur. J'ai cherché sur google, mais sans succès.

Merci d'avance,

Aldo

source d'informationauteur aldux

24

Pour SQL luminaires, vous auriez à en particulier les états d'insertion pour les auth tables. Vous pouvez trouver le schéma de la auth tables avec la commande python manage.py sql auth.

La plus facile et la base de données de manière indépendante (sauf si vous avez quelques SQL supplémentaires de magie que vous souhaitez exécuter), est de faire juste un JSON ou YAML luminaire fichier dans le répertoire fixtures de votre application avec des données comme ceci:
```
- model: auth.user
  pk: 100000
  fields:
    first_name: Admin
    last_name: User
    username: admin
    password: "<a hashed password>"
```
Vous pouvez générer un hachage de mot de passe rapidement dans un django shell
```
>>> from django.contrib.auth.models import User
>>> u = User()
>>> u.set_password('newpass')
>>> u.password
'sha1$e2fd5$96edae9adc8870fd87a65c051e7fdace6226b5a8'
```
Ce seront chargées à chaque fois que vous exécutez syncdb.
8

Vous êtes à la recherche pour loaddata:
```
manage.py loadata path/to/your/fixtureFile
```
Mais je pense que la commande ne peut traiter que les fichiers en XML, YAML, en Python ou en format JSON (voir ici). Pour créer de tels fichiers appropriés, avoir un regard sur le dumpdata méthode.

Merci pour vos réponses. J'ai trouvé la solution qui fonctionne pour moi, et pour la coïncidence était l'une de Brian de suggestion. Ici, il est:

Sapins j'ai déconnecté le signal qui a créé le Super-Utilisateur après syncdb, car j'ai mon super utilisateur dans mon auth_user appareil:

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")

Puis j'ai créé un signal à être appelée après syncdb:

< myproject >/< myapp >/management/__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")

Et dans mon settings.py j'ai ajouté FIXTURES_FILE avec le chemin d'accès à mon .fichier sql avec sql dump.

Une chose que je n'ai pas encore trouvé est de savoir comment le feu ce signal qu'après les tables sont créées, et pas à chaque fois syncdb est déclenché. Une solution temporaire pour ce qui est de l'utilisation de INSERT IGNORE INTO dans ma commande sql.

Je sais que cette solution est loin d'être parfait, et les critiques/améliorations/avis sont les bienvenus!

Ce qui concerne,

Aldo

4

Il y a un truc pour ça: (testé sur Django 1.3.1)

Solution:
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
Prochaine fois que vous exécutez python manage.py syncdbDjango va charger la auth luminaire automatiquement.

Explication:
1. Juste faire un vide d'application pour tenir le dossier déplacements imposés. Laissez __init__py, models.py et views.py alors que Django reconnaît comme une application et pas seulement un dossier.
2. Faire le dossier déplacements imposés dans l'application.
3. python manage.py dumpdata auth d'un dumping de la "auth" données dans la base de données avec tous les Groupes et Utilisateurs de l'information. Le reste de la commande simplement redirige la sortie vers un fichier appelé "initial_data.json", qui est celui que Django recherche lorsque vous exécutez "syncdb".
4. Il suffit d'inclure auth_fix dans INSTALLED_APPS à l'intérieur settings.py.
Cet exemple montre comment le faire en JSON, mais vous pouvez utiliser le format de votre choix.
3

Une option est d'importer votre auth.L'utilisateur SQL manuellement et par la suite de vidage à une norme de Django luminaire (nom, il initial_data si vous voulez syncdb pour le trouver). Généralement, vous pouvez mettre ce fichier dans n'importe quelle application de luminaires dir depuis le bridées données assortie avec le bon app_label. Ou vous pouvez créer un vide/mannequin d'application et de le placer là.

Une autre option est de remplacer la commande syncdb et d'appliquer l'appareil dans une manière que vous voyez l'ajustement.

Je suis d'accord avec Felix qu'il n'y a pas de non-trivial naturel crochet dans Django pour le remplissage de contrib apps avec SQL.

Si vous arrive d'être faire des migrations de base de données avec le sud, la création d'utilisateurs est très simple.

Tout d'abord, créer un nu-migration des données. Il doit être inclus dans certains de l'application. Si vous avez une application les plus courantes lorsque vous placez le code partagé, que serait un bon choix. Si vous avez une application où vous vous concentrez liées à l'utilisateur, le code, ce serait encore mieux.

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

Pertinentes de la migration de code pourrait ressembler à quelque chose comme ceci:

# 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': '[email protected]',
            'password': 'nancypassword',
            'staff': True,
            'superuser': True
        },
        {
            'username': 'joe',
            'email': '',
            'password': 'joepassword',
            'staff': True,
            'superuser': False
        },
        {
            'username': 'susan',
            'email': '[email protected]',
            '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()

Puis exécutez simplement la migration et de l'authentification des utilisateurs doit être inséré.

$ python manage.py migrate <some app name>

1

J'ai simplement ajouté des instructions SQL dans la coutume fichier sql pour un autre modèle. J'ai choisi mon Employé modèle, car il dépend de auth_user.
La coutume SQL que j'ai écrit en fait lit à partir de mon héritage, demande et tire les infos de l'utilisateur à partir d'elle, et l'utilise REMPLACER plutôt que d'INSÉRER (je suis en utilisant MySQL) afin que je puisse l'exécuter à chaque fois que je veux.
Et je l'ai mis REMPLACER...instruction SELECT dans une procédure, de sorte qu'il est facile d'exécuter manuellement ou de façon planifiée avec cron.

Vous devez vous connecter pour publier un commentaire.