Création de champs de modèles dynamiques dans django

Il existe quelques approches:

• clé/valeur de modèle (facile, bien pris en charge)
• Données JSON dans un TextField (facile, flexible, peut pas rechercher/index facilement)
• Dynamique, la définition du modèle (pas facile, beaucoup de problèmes cachés)

Il semble que vous voulez le dernier, mais je ne suis pas sûr que c'est le meilleur pour vous. Django est très facile de modifier/mettre à jour, si les admins veulent champs supplémentaires, il suffit d'ajouter eux et de les utiliser au sud de migrer. Je n'aime pas les génériques de clé/valeur schémas de base de données, le point de l'ensemble d'un cadre puissant comme Django, c'est que vous pouvez facilement écrire et de réécrire des schémas personnalisés sans avoir recours à des principes généraux.

Si vous devez autoriser les utilisateurs du site/administrateurs de définir directement leurs données, je suis sûr que d'autres vont vous montrer comment faire les deux premières approches ci-dessus. La troisième approche est ce que vous demandez, et un peu plus fou, je vais vous montrer comment le faire. Je ne recommande pas de l'utiliser dans presque tous les cas, mais il est parfois approprié.

Les modèles de dynamique de

Une fois que vous savez quoi faire, c'est relativement simple. Vous aurez besoin de:

• 1 ou 2 modèles pour stocker les noms et les types des champs
• (facultatif) Un modèle abstrait pour définir les fonctionnalités courantes de votre (sous-classé) les modèles de dynamique de
• Une fonction pour construire (ou reconstruire) le modèle dynamique lorsque nécessaire
• Code pour créer ou mettre à jour les tables de base de données lorsque les champs sont ajoutés/supprimés/renommé

1. Le stockage de la définition du modèle

C'est à vous de voir. J'imagine que vous aurez un modèle CustomCarModel et CustomField pour permettre à l'utilisateur/administrateur de définir et de stocker les noms et les types de champs que vous le souhaitez. Vous n'avez pas de miroir Django champs directement, vous pouvez faire vos propres types que l'utilisateur peut mieux comprendre.

Utiliser un forms.ModelForm en ligne jeux de formulaires pour permettre à l'utilisateur de construire leur classe personnalisée.

2. Modèle abstrait

Encore une fois, c'est très simple, il suffit de créer un modèle de base avec la commune de champs/méthodes pour tous vos modèles de dynamique. Ce modèle abstrait.

3. Construire un modèle dynamique

Définir une fonction qui prend les informations nécessaires (peut-être une instance de votre classe à partir d' #1) et produit un modèle de classe. C'est un exemple de base:

from django.db.models.loading import cache
from django.db import models


def get_custom_car_model(car_model_definition):
  """ Create a custom (dynamic) model class based on the given definition.
  """
  # What's the name of your app?
  _app_label = 'myapp'

  # you need to come up with a unique table name
  _db_table = 'dynamic_car_%d' % car_model_definition.pk

  # you need to come up with a unique model name (used in model caching)
  _model_name = "DynamicCar%d" % car_model_definition.pk

  # Remove any exist model definition from Django's cache
  try:
    del cache.app_models[_app_label][_model_name.lower()]
  except KeyError:
    pass

  # We'll build the class attributes here
  attrs = {}

  # Store a link to the definition for convenience
  attrs['car_model_definition'] = car_model_definition

  # Create the relevant meta information
  class Meta:
      app_label = _app_label
      db_table = _db_table
      managed = False
      verbose_name = 'Dynamic Car %s' % car_model_definition
      verbose_name_plural = 'Dynamic Cars for %s' % car_model_definition
      ordering = ('my_field',)
  attrs['__module__'] = 'path.to.your.apps.module'
  attrs['Meta'] = Meta

  # All of that was just getting the class ready, here is the magic
  # Build your model by adding django database Field subclasses to the attrs dict
  # What this looks like depends on how you store the users's definitions
  # For now, I'll just make them all CharFields
  for field in car_model_definition.fields.all():
    attrs[field.name] = models.CharField(max_length=50, db_index=True)

  # Create the new model class
  model_class = type(_model_name, (CustomCarModelBase,), attrs)

  return model_class

4. Code pour mettre à jour les tables de base de données

Le code ci-dessus va générer un modèle dynamique pour vous, mais ne va pas créer les tables de la base. Je recommande d'utiliser le Sud pour la manipulation de la table. Ici sont un couple de fonctions qui vous pouvez vous connecter à pré/post-enregistrement des signaux:

import logging
from south.db import db
from django.db import connection

def create_db_table(model_class):
  """ Takes a Django model class and create a database table, if necessary.
  """
  table_name = model_class._meta.db_table
  if (connection.introspection.table_name_converter(table_name)
                    not in connection.introspection.table_names()):
    fields = [(f.name, f) for f in model_class._meta.fields]
    db.create_table(table_name, fields)
    logging.debug("Creating table '%s'" % table_name)

def add_necessary_db_columns(model_class):
  """ Creates new table or relevant columns as necessary based on the model_class.
    No columns or data are renamed or removed.
    XXX: May need tweaking if db_column != field.name
  """
  # Create table if missing
  create_db_table(model_class)

  # Add field columns if missing
  table_name = model_class._meta.db_table
  fields = [(f.column, f) for f in model_class._meta.fields]
  db_column_names = [row[0] for row in connection.introspection.get_table_description(connection.cursor(), table_name)]

  for column_name, field in fields:
    if column_name not in db_column_names:
      logging.debug("Adding field '%s' to table '%s'" % (column_name, table_name))
      db.add_column(table_name, column_name, field)

Et là vous l'avez! Vous pouvez appeler get_custom_car_model() de livrer un django modèle, que vous pouvez utiliser pour faire des django requêtes:

CarModel = get_custom_car_model(my_definition)
CarModel.objects.all()

Problèmes

• Vos modèles sont cachés de Django jusqu'à ce que le code de création est exécuté. Vous pouvez toutefois exécuter get_custom_car_model pour chaque instance de votre définitions dans le class_prepared signal pour votre modèle de définition.
• ForeignKeys/ManyToManyFields peut ne pas fonctionner (je n'ai pas essayé)
• Vous souhaitez utiliser Django modèle cache de sorte que vous n'avez pas à exécuter des requêtes et créer le modèle à chaque fois que vous souhaitez utiliser. J'ai quitté ce ci-dessus pour des raisons de simplicité
• Vous pouvez obtenir vos modèles de dynamique dans l'admin, mais vous aurez besoin de créer dynamiquement de l'administrateur de classe, et s'inscrire/se réinscrire/unregister de façon appropriée à l'aide de signaux.

Aperçu

Si vous êtes bien avec la complication supplémentaire et des problèmes, profitez-en! C'est en cours d'exécution, il fonctionne exactement comme prévu grâce à Django et Python flexibilité. Vous pouvez nourrir votre modèle dans Django ModelForm pour permettre à l'utilisateur de modifier leurs instances, et d'effectuer des requêtes à l'aide de la base de données de champs directement. Si il ya quelque chose que vous ne comprenez pas dans le ci-dessus, vous êtes probablement mieux de ne pas prendre cette approche (j'ai volontairement pas expliqué ce que certains concepts sont pour les débutants). Keep it Simple!

Je ne pense vraiment pas que beaucoup de gens ont besoin de cela, mais je l'ai utilisé moi-même, où nous avons eu beaucoup de données dans les tables et vraiment, vraiment besoin pour permettre aux utilisateurs de personnaliser les colonnes, ce qui a changé rarement.

Voici mon test simple dans django shell - j'ai juste tapé et il semble bien fonctionner-

    In [25]: attributes = {
               "__module__": "lekhoni.models",
               "name": models.CharField(max_length=100),
                "address":  models.CharField(max_length=100),
            }

    In [26]: Person = type('Person', (models.Model,), attributes)

    In [27]: Person
    Out[27]: class 'lekhoni.models.Person'

    In [28]: p1= Person()

    In [29]: p1.name= 'manir'

    In [30]: p1.save()

    In [31]: Person.objects.a
    Person.objects.aggregate  Person.objects.all        Person.objects.annotate   

    In [32]: Person.objects.all()

    Out[33]: [Person: Person object]

Il semble très simple - je ne sais pas pourquoi il ne devrait pas être considérée comme une option de la Réflexion est très commun est d'autres langages comme C# ou Java - de toute façon, je suis très nouveau à django choses-