primary - "Foreign Keys" en bases de datos muy separadas en Django

models django primary key

Question

He escrito un sitio de Django que usa dos bases de datos diferentes. Uno es el local, vamos a llamarlo, "Django", una base de datos que almacena todas las tablas estándar de una instalación bastante estándar (autenticación, sitios, comentarios, etc.) más algunas tablas adicionales.

La mayoría de los datos, incluidos los usuarios, provienen de una base de datos en otro servidor, llamémosla la base de datos "Legacy".

Estoy buscando sugerencias sobre formas limpias y pitónicas de conectar las dos bases de datos, particularmente con respecto a los usuarios.

Estoy usando un modelo de proxy, que funciona muy bien cuando puedo usarlo explícitamente, pero tengo problemas cuando accedo al objeto del usuario como un objeto relacionado (por ejemplo, cuando uso el sistema integrado de comentarios django).

Así es como se ve el código:

models.py : (apunta a la base de datos Django)

from django.db import models
from django.conf import settings
from django.contrib.auth.models import User as AuthUser, UserManager as AuthUserManager, AnonymousUser as AuthAnonymousUser

class UserPerson(models.Model):
    user = models.OneToOneField(AuthUser, related_name="person")
    person_id = models.PositiveIntegerField(verbose_name=''Legacy ID'')

    def __unicode__(self):
        return "%s" % self.get_person()

    def get_person(self):
        if not hasattr(self, ''_person''):
            from legacy_models import Person
            from utils import get_person_model
            Person = get_person_model() or Person
            self._person = Person.objects.get(pk=self.person_id)
        return self._person
    person=property(get_person)

class UserManager(AuthUserManager):
    def get_for_id(self, id):
        return self.get(person__person_id=id)

    def get_for_email(self, email):
        try:
            person = Person.objects.get(email=email)
            return self.get_for_id(person.pk)
        except Person.DoesNotExist:
            return User.DoesNotExist

    def create_user(self, username, email, password=None, *args, **kwargs):
        user = super(UserManager,self).create_user(username, email, password, *args, **kwargs)
        try:
            person_id = Person.objects.get(email=email).pk
            userperson, created = UserPerson.objects.get_or_create(user=user, person_id=person_id)
        except Person.DoesNotExist:
            pass
        return user

class AnonymousUser(AuthAnonymousUser):
    class Meta:
        proxy = True

class User(AuthUser):
    class Meta:
        proxy=True

    def get_profile(self):  
        """
        Returns the Person record from the legacy database
        """
        if not hasattr(self, ''_profile_cache''):
            self._profile_cache = UserPerson.objects.get(user=self).person
        return self._profile_cache

    objects = UserManager()

legacy_models.py : (apunta a la base de datos "Legacy")

class Person(models.Model):
    id = models.AutoField(primary_key=True, db_column=''PeopleID'') # Field name made lowercase.
    code = models.CharField(max_length=40, blank=True, db_column="person_code", unique=True)
    first_name = models.CharField(max_length=50, db_column=''firstName'', blank=True) # Field name made lowercase.
    last_name = models.CharField(max_length=50, db_column=''lastName'', blank=True) # Field name made lowercase.
    email = models.CharField(max_length=255, blank=True)

    def __unicode__(self):
        return "%s %s" % (self.first_name, self.last_name)

    def get_user(self):
        from models import User
        if not hasattr(self,''_user''):
            self._user = User.objects.get_for_id(self.pk)
        return self._user
    user = property(get_user)

    class Meta:
        db_table = u''People''

También he mejorado mi propio middleware, por lo que request.user es el User proxy.

El verdadero problema es cuando estoy usando algo que tiene al usuario como un objeto relacionado, particularmente en una plantilla donde tengo incluso menos control.

En la plantilla:

{{ request.user.get_profile }} 
{# this works and returns the related Person object for the user #}

{% for comment in comments %} {# retrieved using the built-in comments app %}
    {{ comment.user.get_profile }}
    {# this throws an error because AUTH_PROFILE_MODULE is not defined by design #}
{% endfor %}

Si no se crea una versión envolvente del sistema de comentarios que utiliza mi modelo de Usuario proxy, ¿hay algo más que pueda hacer?

Answer 1

Así es como lo resolví. Dejé de usar el proxy de usuario por completo.

models.py :

from django.db import models
from legacy_models import Person
from django.contrib.auth.models import User

class UserPerson(models.Model):
    user = models.OneToOneField(User, related_name="person")
    person_id = models.PositiveIntegerField(verbose_name=''PeopleID'', help_text=''ID in the Legacy Login system.'')

    def __unicode__(self):
        return "%s" % self.get_person()

    def get_person(self):
        if not hasattr(self, ''_person''):
            self._person = Person.objects.get(pk=self.person_id)
        return self._person
    person=property(get_person)

class LegacyPersonQuerySet(models.query.QuerySet):
    def get(self, *args, **kwargs):
        person_id = UserPerson.objects.get(*args, **kwargs).person_id
        return LegacyPerson.objects.get(pk=person_id)

class LegacyPersonManager(models.Manager):
    def get_query_set(self, *args, **kwargs):
        return LegacyPersonQuerySet(*args, **kwargs)

class LegacyPerson(Person):
    objects = LegacyPersonManager()

    class Meta:
        proxy=True

y legacy_models.py :

class Person(models.Model):
    id = models.AutoField(primary_key=True, db_column=''PeopleID'') # Field name made lowercase.
    code = models.CharField(max_length=40, blank=True, db_column="person_code", unique=True)
    first_name = models.CharField(max_length=50, db_column=''firstName'', blank=True) # Field name made lowercase.
    last_name = models.CharField(max_length=50, db_column=''lastName'', blank=True) # Field name made lowercase.
    email = models.CharField(max_length=255, blank=True)

    def __unicode__(self):
        return "%s %s" % (self.first_name, self.last_name)

    def get_user(self):
        from models import User
        if not hasattr(self,''_user''):
            self._user = User.objects.get_for_id(self.pk)
        return self._user
    def set_user(self, user=None):
        self._user=user
    user = property(get_user, set_user)

    class Meta:
        db_table = u''People''

Finalmente, en settings.py :

AUTH_PROFILE_MODULE = ''myauth.LegacyPerson''

Esta es una solución más simple, ¡pero al menos funciona! Significa que siempre que quiera el registro heredado tengo que llamar a user_profile , y eso significa que hay una consulta adicional para cada registro de usuario, pero esto es una compensación justa porque en realidad no es muy probable que lo haga. una verificación cruzada que a menudo.