django通过引用外键使用多个对象获取数据

我有两个数据模型，一个是User，另一个是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）表：

用户的模型定义：

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 "/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 world很陌生。

好吧，我想你是想从auth.User.username转到ShibUser来实现这一点，请按照foreignkey倒过来：

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，而不是foreignkey，这样事情就会变得更简单：

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来改进这一点

好的，因此我认为您正在尝试从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，而不是foreignkey，这样事情就会变得更简单：

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来改进它

请发布您的模型定义。ShibUser->User不应该是OneToOne关系吗？是的，它是一对一的。auth_User table不是我实现的，它与我使用的框架一起提供。我添加了ShibUser表，请发布您的模型定义。ShibUser->User不应该是一对一关系吗？是的，它是一对一关系。auth_User表不是我实现的，它与我使用的框架一起提供。我添加了ShibUser表，这确实有效，但在我的表单中，正如您所看到的，我已经有了user对象，而不是

user=user.objects.get（username=username）

我可以使用该对象吗？我想您可能也可以使用

user.shib\u user

。或者，尝试使用。@如果已经有用户对象，请确定是否找到缺少的分号，然后使用它。我将编辑第三种方法来执行此查找，这也确实有效，但在我的表单中，正如您所看到的，我已经有了user对象，而不是

user=user.objects.get（username=username）

我可以使用该对象吗？我想您可能也可以使用

user.shib_user

。或者，尝试使用。@如果已经有用户对象，请确定是否找到缺少的分号，然后使用它。我还将编辑第三种方法来执行此查找