Django中的非常独立的数据库中的“外键”

问题描述：

我写了一个使用两个不同数据库的Django站点。一个是本地的，我们称之为“Django”，这个数据库存储了来自标准安装的所有标准表 - auth，网站，评论等 - 以及一些额外的表格。Django中的非常独立的数据库中的“外键”

大部分数据（包括用户）来自另一台服务器上的数据库，我们称之为“传统”数据库。

我在寻找关于连接两个数据库的干净，pythonic方式的建议，特别是关于用户的。

我正在使用代理模型，该模型在我可以明确使用它的时候效果很好，但是当我作为相关对象访问用户对象时遇到了问题（例如，当使用内置的django评论系统）。

下面的代码是什么样子：

models.py：（指向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：（指向 “遗产” 数据库）

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'

我也掀起了自己的中间件，所以request.user是pr氧还User对象也。

真正的问题是，当我使用的东西有用户作为相关的对象，特别是在我有更少的控制模板。

在模板：

{{ 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 %}

短创建它使用我的代理用户模型取而代之的，是有什么事我可以做评论系统的包装版本的？

答

下面是我解决它的方法。我完全停止使用用户代理。

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

和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'

最后，在settings.py：

AUTH_PROFILE_MODULE = 'myauth.LegacyPerson'

这是一个更简单的解决方案，但至少可以工作！这意味着只要我需要传统记录，我必须拨打user_profile，这意味着每个用户记录都有一个额外的查询，但这是一个公平的折衷，因为实际上我不太可能会这样做经常交叉检查。

Django中的非常独立的数据库中的“外键”

相关推荐