django通過引用外鍵獲取數據使用多個對象

Question

我有兩個數據模型，一個是用戶，另一個是ShibUser，ShibUser通過存儲用戶表的ID作爲其外鍵與用戶關聯。

這裏是我的ShibUser表：

+----+--------------+------------------+----------------+ 
| id | auth_user_id | shib_username | shib_user_role | 
+----+--------------+------------------+----------------+ 
| 1 |   4 | auser@domain.edu | Student  | 
| 2 |   5 | buser@domain.edu | Student  | 
+----+--------------+------------------+----------------+ 

從django.db進口車型 從askbot.deps.django_authopenid.models導入用戶

class ShibUser(models.Model): 
    auth_user = models.ForeignKey(User) 
    shib_username = models.CharField(max_length = 200) 
    shib_user_role = models.CharField(max_length = 200) 

這裏是我的用戶（AUTH_USER）表：

+----+----------------+------------+--------+ 
| id | username  | reputation | status | 
+----+----------------+------------+--------+ 
| 4 | aaUser   |   1 | w  | 
| 5 | MrBUser_Cool |   1 | w  | 
+----+----------------+------------+--------+ 

用戶模型定義：

class User(models.Model): 
    """ 
    Users within the Django authentication system are represented by this 
    model. 

    Username and password are required. Other fields are optional. 
    """ 
    username = models.CharField(_('username'), max_length=30, unique=True, 
     help_text=_('Required. 30 characters or fewer. Letters, numbers and ' 
        '@/./+/-/_ characters')) 
    first_name = models.CharField(_('first name'), max_length=30, blank=True) 
    last_name = models.CharField(_('last name'), max_length=30, blank=True) 
    email = models.EmailField(_('e-mail address'), blank=True) 
    password = models.CharField(_('password'), max_length=128) 
    is_staff = models.BooleanField(_('staff status'), default=False, 
     help_text=_('Designates whether the user can log into this admin ' 
        'site.')) 
    is_active = models.BooleanField(_('active'), default=True, 
     help_text=_('Designates whether this user should be treated as ' 
        'active. Unselect this instead of deleting accounts.')) 
    is_superuser = models.BooleanField(_('superuser status'), default=False, 
     help_text=_('Designates that this user has all permissions without ' 
        'explicitly assigning them.')) 
    last_login = models.DateTimeField(_('last login'), default=timezone.now) 
    date_joined = models.DateTimeField(_('date joined'), default=timezone.now) 
    groups = models.ManyToManyField(Group, verbose_name=_('groups'), 
     blank=True, help_text=_('The groups this user belongs to. A user will ' 
           'get all permissions granted to each of ' 
           'his/her group.')) 
    user_permissions = models.ManyToManyField(Permission, 
     verbose_name=_('user permissions'), blank=True, 
     help_text='Specific permissions for this user.') 
    objects = UserManager() 

    class Meta: 
     verbose_name = _('user') 
     verbose_name_plural = _('users') 

    def __unicode__(self): 
     return self.username 

    def natural_key(self): 
     return (self.username,) 

    def get_absolute_url(self): 
     return "https://stackoverflow.com/users/%s/" % urllib.quote(smart_str(self.username)) 

    def is_anonymous(self): 
     """ 
     Always returns False. This is a way of comparing User objects to 
     anonymous users. 
     """ 
     return False 

    def is_authenticated(self): 
     """ 
     Always return True. This is a way to tell if the user has been 
     authenticated in templates. 
     """ 
     return True 

    def get_full_name(self): 
     """ 
     Returns the first_name plus the last_name, with a space in between. 
     """ 
     full_name = u'%s %s' % (self.first_name, self.last_name) 
     return full_name.strip() 

    def set_password(self, raw_password): 
     self.password = make_password(raw_password) 

    def check_password(self, raw_password): 
     """ 
     Returns a boolean of whether the raw_password was correct. Handles 
     hashing formats behind the scenes. 
     """ 
     def setter(raw_password): 
      self.set_password(raw_password) 
      self.save() 
     return check_password(raw_password, self.password, setter) 

    def set_unusable_password(self): 
     # Sets a value that will never be a valid hash 
     self.password = make_password(None) 

    def has_usable_password(self): 
     return is_password_usable(self.password) 

    def get_group_permissions(self, obj=None): 
     """ 
     Returns a list of permission strings that this user has through his/her 
     groups. This method queries all available auth backends. If an object 
     is passed in, only permissions matching this object are returned. 
     """ 
     permissions = set() 
     for backend in auth.get_backends(): 
      if hasattr(backend, "get_group_permissions"): 
       if obj is not None: 
        permissions.update(backend.get_group_permissions(self, 
                    obj)) 
       else: 
        permissions.update(backend.get_group_permissions(self)) 
     return permissions 

    def get_all_permissions(self, obj=None): 
     return _user_get_all_permissions(self, obj) 

    def has_perm(self, perm, obj=None): 
     """ 
     Returns True if the user has the specified permission. This method 
     queries all available auth backends, but returns immediately if any 
     backend returns True. Thus, a user who has permission from a single 
     auth backend is assumed to have permission in general. If an object is 
     provided, permissions for this specific object are checked. 
     """ 

     # Active superusers have all permissions. 
     if self.is_active and self.is_superuser: 
      return True 

     # Otherwise we need to check the backends. 
     return _user_has_perm(self, perm, obj) 

    def has_perms(self, perm_list, obj=None): 
     """ 
     Returns True if the user has each of the specified permissions. If 
     object is passed, it checks if the user has all required perms for this 
     object. 
     """ 
     for perm in perm_list: 
      if not self.has_perm(perm, obj): 
       return False 
     return True 

    def has_module_perms(self, app_label): 
     """ 
     Returns True if the user has any permissions in the given app label. 
     Uses pretty much the same logic as has_perm, above. 
     """ 
     # Active superusers have all permissions. 
     if self.is_active and self.is_superuser: 
      return True 

     return _user_has_module_perms(self, app_label) 

    def email_user(self, subject, message, from_email=None): 
     """ 
     Sends an email to this User. 
     """ 
     send_mail(subject, message, from_email, [self.email]) 

    def get_profile(self): 
     """ 
     Returns site-specific profile for this user. Raises 
     SiteProfileNotAvailable if this site does not allow profiles. 
     """ 
     if not hasattr(self, '_profile_cache'): 
      from django.conf import settings 
      if not getattr(settings, 'AUTH_PROFILE_MODULE', False): 
       raise SiteProfileNotAvailable(
        'You need to set AUTH_PROFILE_MODULE in your project ' 
        'settings') 
      try: 
       app_label, model_name = settings.AUTH_PROFILE_MODULE.split('.') 
      except ValueError: 
       raise SiteProfileNotAvailable(
        'app_label and model_name should be separated by a dot in ' 
        'the AUTH_PROFILE_MODULE setting') 
      try: 
       model = models.get_model(app_label, model_name) 
       if model is None: 
        raise SiteProfileNotAvailable(
         'Unable to load the profile model, check ' 
         'AUTH_PROFILE_MODULE in your project settings') 
       self._profile_cache = model._default_manager.using(
            self._state.db).get(user__id__exact=self.id) 
       self._profile_cache.user = self 
      except (ImportError, ImproperlyConfigured): 
       raise SiteProfileNotAvailable 
     return self._profile_cache 

我有一個代表用戶配置文件的形式，我想向用戶顯示的角色，我有進口都在我的表單中的對象，但我奮力如何真正基於用戶角色用戶對象用戶名。

這裏是我嘗試添加該功能的準確地點：

from askbot.shibapp.models import ShibUser 
from django.contrib.auth.models import User 

    def __init__(self, user, *args, **kwargs): 
     super(EditUserForm, self).__init__(*args, **kwargs) 
     logging.debug('initializing the form') 
     shib_user_role = ShibUser.objects.get(auth_user=4) 
     if askbot_settings.EDITABLE_SCREEN_NAME: 
      self.fields['username'] = UserNameField(label=_('Screen name')) 
      self.fields['username'].initial = user.username 
      self.fields['username'].user_instance = user 
     self.fields['email'].initial = user.email 
     self.fields['realname'].initial = user.real_name 
     self.fields['website'].initial = user.website 
     self.fields['city'].initial = user.location 
     if askbot_settings.EDITABLE_SCREEN_NAME: 
     self.fields['role'].initial = "test_role" (Instead of 'test_role') 

我是很新的Django的世界。

Answer 1

好了，所以我想你想從auth.User.username去ShibUser這樣做遵循ForeignKeys向後：

user = User.objects.get(username=username) 
# for reverse relationships the foo_set is created by django enabling 
# reverse relationship. You can override this by providing a related_name 
shibuser = user.shibuser_set.get() 
# Alternative syntax 
shibuser = user.shibuser_set.all()[0] 

從那裏你可以得到你的ShibUser作用。如果每個用戶可以存在多個ShibUser，那麼您希望刪除該索引，而不是使用ShibUser對象的查詢集。

如果只有一個ShibUser對象可以爲每個用戶存在，您應該使這個OneToOneField，而不是一個外鍵，事情變得更簡單：

shibuser = user.shibuser 

最後，你甚至可以從ShibUser模型開始，並與它的工作：

shibuser = ShibUser.objects.get(auth_user__username=username) 
# Or if you already had the User object instance 
shibuser = ShibUser.objects.get(auth_user=user) 

請記住幾個例外可以引發這取決於方法：用戶不能存在或給定用戶的ShibUser不能存在。也許多個ShibUser可能與單個用戶相關，因此.get（）調用將導致MultipleObjectsReturned異常。你的模式對你的用例並不是很緊張，聽起來像是這樣，我可能會用OneToOneField來改善它。