Administrador de Django: generar automáticamente múltiples líneas con el mismo modelo

Question

Escribo mi primera aplicación Django. Tengo el siguiente modelo de base de datos:

class Person(models.Model): 
    first_name   = models.CharField(max_length = 100) 
    last_name   = models.CharField(max_length = 100) 

class InformationType(models.Model): 
    name = models.CharField(max_length = 100) 

class Information(models.Model): 

    person  = models.ForeignKey(Person) 
    info_type = models.ForeignKey(InformationType) 
    info   = models.CharField(max_length = 200) 

quiero crear múltiples inlines en Django Admin (clase PersonAdmin (ModelAdmin)) mediante el fraccionamiento de Modelo de información por tipos y hacerlo de forma dinámica. También quiero ocultar (excluir) el campo 'info_type' de la interfaz de usuario y llenarlo automáticamente con el valor correspondiente.

Puedo crear dinámicamente líneas con los datos de 'Información' filtrados por 'tipo_info' pero ocultar este campo en la interfaz de usuario lo hace vacío al guardar.

¿Cómo puedo hacerlo? ¿Es posible crear un campo oculto? ¿O dónde debería almacenar el valor 'info_type'?

Googled dura y no encontré nada =)

adjuntos: La OK. He modificado la clase 'Información':

class Information(models.Model): 

    def save(self, *args, **kwargs): 
     self.info_type = self.fixed_info_type 
     super(Information, self).save(*args, **kwargs) 

... y Maqued pocos servidores proxy:

class InformationManager(models.Manager): 

    def __init__(self, info_type, *args, **kwargs): 
     self.__info_type = info_type 
     super(InformationManager, self).__init__(*args, **kwargs) 

    def get_query_set(self, *args, **kwargs): 
     return super(self.__class__, self).get_query_set(*args, **kwargs).filter(info_type=self.__info_type) 

class PhoneInformation(Information): 

    fixed_info_type = 'PHONE' 
    objects = InformationManager(fixed_info_type) 
    class Meta: 
     proxy = True 

class EmailInformation(Information): 

    fixed_info_type = 'EMAIL' 
    objects = InformationManager(fixed_info_type) 
    class Meta: 
     proxy = True 

en admin.py:

from contacts.models import Person, PhoneInformation, EmailInformation 
class PersonAdmin(admin.ModelAdmin): 
    __inlines = [] 

    class classproperty(property): 
     def __get__(self, instance, owner): 
      return super(self.__class__, self).fget.__get__(None, owner)() 

    @classproperty  
    @classmethod 
    def inlines(cls): 

     def get_inline(InformationModel): 
      class Inline(admin.TabularInline): 
       model = InformationModel 
       exclude= ['info_type'] 

      return Inline 

     if not cls.__inlines: 
      for InformationModel in [PhoneInformation, EmailInformation]: 
       cls.__inlines.append(get_inline(InformationModel)) 
     return cls.__inlines 

Así se ve feo y don' cumplir con los principios DRY No puedo crear proxies de la misma manera que InlineAdmin. Recupera el mismo objeto cada vez.

Answer 1

Algo que he hecho en el pasado es:

Cree sus diversas formas en línea, reemplazando el conjunto de consultas para cada uno para permitir sólo determinados subconjuntos de la información por tipo

(Mira esto en busca de inspiración: Limit the queryset of entries displayed for a django admin Inline)

Answer 2

He encontrado la solución. Ahora puedo crear modelos de proxy dinámicos sobre la marcha. models.py:

class Person(models.Model): 
    first_name   = models.CharField(max_length = 100) 
    last_name   = models.CharField(max_length = 100) 

class InformationType(models.Model): 
    class Meta: 
     ordering = ['order'] 

    name = models.CharField(max_length = 200) 
    order = models.IntegerField() 

class Information(models.Model): 

    person  = models.ForeignKey(Person) 
    info_type = models.ForeignKey(InformationType) 
    value  = models.CharField(max_length = 200) 

    @classmethod  
    def getProxy(cls, info_type): 
     class InformationManager(models.Manager): 
      def get_query_set(self, *args, **kwargs): 
       return super(self.__class__, self).get_query_set(*args, **kwargs).filter(info_type = info_type) 

     def save(self, *args, **kwargs): 
      self.info_type = info_type 
      super(Information, self).save(*args, **kwargs) 

     class Meta: 
      proxy = True 

     return type(
        'Information'+str(info_type.pk), 
        (Information,), 
        { 
         'Meta': Meta, 
         'save': save, 
         '__module__': 'contacts.models', 
         'objects': InformationManager(), 

        } 
        ) 

en admin.py:

class PersonAdmin(admin.ModelAdmin): 

    __inlines = [] 

    class classproperty(property): 
     def __get__(self, instance, owner): 
      return super(self.__class__, self).fget.__get__(None, owner)() 


    @classproperty  
    @classmethod 
    def inlines(cls): 
     def get_inline(info_model): 
      class Inline(admin.TabularInline): 
       model = info_model 
       exclude= ['info_type'] 
      return Inline 

     if not cls.__inlines: 
      for info_model in [Information.getProxy(info_type) for info_type in InformationType.objects.all()]: 
       cls.__inlines.append(get_inline(info_model)) 
     return cls.__inlines