Django 模型 : how to overcome 'through' ManyToMany option limitation

Question

我正在开发一款应用程序，允许用户自己创建和管理用户组。

问题是我想存储哪个用户向任何组添加了新成员。

这些是我目前的模型:

class UserManagedGroup(Group):

    leader = models.ForeignKey(User, verbose_name=_('group leader'), related_name='leaded_groups')
    members = models.ManyToManyField(User, verbose_name=_('members'), through='Membership',
                                     related_name='managed_groups')

class Membership(models.Model):

    user = models.ForeignKey(User, related_name='memberships')
    group = models.ForeignKey(UserManagedGroup, related_name='memberships')
    info = models.OneToOneField('MembershipInfo', verbose_name=_('membership information'))

    class Meta:
        unique_together = ['user', 'group']

class MembershipInfo(models.Model):

    date_added = models.DateField(_('date added'), auto_now_add=True)
    made_member_by = models.ForeignKey(User, verbose_name=_('user who made him a member'))
    membership_justification = models.TextField(_('membership justification'), blank=True, default='')


@receiver(signals.post_delete, sender=Membership)
def delete_membership_info(sender, instance, *args, **kwargs):
    if instance.info.pk:
        instance.info.delete()

如您所见，我有一个愚蠢的 MembershipInfo 模型，由于其字段的性质，它更适合与 Membership 合并。此外，MembershipInfo 的生命周期与其 Membership 绑定(bind)在一起(这就是我必须创建此 post_delete 信号连接的原因)。

因此我无法合并它们:

Your intermediate model must contain one - and only one - foreign key to the target model (this would be Person in our example). If you have more than one foreign key, a validation error will be raised.

(在我的例子中，我不能对用户使用 2 个外键)

现在，这确实有效，但我不喜欢它。它使 Membership 实例创建变得乏味，因为我必须始终首先创建一个 MembershipInfo 实例。此外，2 个查询而不是 1 个。

问题将 2 个外键存储到与我的成员关系绑定(bind)的同一模型(User)的最佳方式。

Answer 1

我刚刚解决了一个类似的问题，其中包括一个中间模型，其中两个外键指向同一目标。这就是我的系统的样子:

class Node(models.Model):
    receivers = models.ManyToManyField('self', through='Connection',  related_name='senders',  symmetrical=False)

class Connection(models.Model):
    sender = models.ForeignKey(Node, related_name='outgoing')
    receiver = models.ForeignKey(Node, related_name='incoming')

我认为这说明了在中间模型中对同一目标使用两个外键的主要要求。也就是说，模型应该有一个 ManyToManyField，其目标为 'self'(递归 ManyToMany)，并且属性 through 指向中间模型。我认为还必须为每个外键分配一个唯一的lated_name。如果您希望递归关系是单向的，则 symmetry=False 参数适用于递归关系，例如Node1 向 Node2 发送信号，但 Node2 不一定向 Node1 发送信号。为了使递归 ManyToMany 使用自定义“通过”模型，必须使用 symmetry=False 定义关系。如果您想使用自定义“通过”模型创建对称递归ManyToMany，可以找到建议here 。

我发现所有这些相互关系相当令人困惑，因此我花了一段时间才选择实际捕获代码正在执行的操作的合理模型属性和相关名称。为了澄清这是如何工作的，如果我有一个节点对象 N，调用 N.receivers.all() 或 N.senders.all() 返回其他节点集分别从 N 接收数据或向 N 发送数据。调用 N.outgoing.all() 或 N.incoming.all() 通过 related_names 访问 Connection 对象本身。请注意，仍然存在一些歧义，即发送者和接收者可以在 ManyToManyField 中交换，并且代码同样可以正常工作，但方向相反。我通过检查测试用例来得出上述结论，以确定“发送者”是否实际上正在发送到“接收者”，反之亦然。

在您的情况下，将两个外键都定位到 User 会增加复杂性，因为如何直接向 User 添加递归 ManyToManyField 并不明显。我认为自定义用户模型的首选方法是通过通过 OneToOneField 连接到用户的代理来扩展它。这可能令人不满意，就像使用 MembershipInfo 扩展 Membership 令人不满意一样，但它至少允许您轻松地向 User 模型添加进一步的自定义。

因此，对于您的系统，我会尝试这样的操作(未经测试):

class Member(models.Model):
    user = models.OneToOneField(User, related_name='member')
    recruiters = models.ManyToManyField('self', through = 'Membership',  related_name = 'recruits',  symmetrical=False)
    other_custom_info = ... 

class UserManagedGroup(Group):
    leader = models.ForeignKey(Member, related_name='leaded_groups')
    members = models.ManyToManyField(Member, through='Membership', related_name='managed_groups')

class Membership(models.Model):
    member = models.ForeignKey(Member, related_name='memberships')
    made_member_by = models.ForeignKey(Member, related_name='recruitments')
    group = models.ForeignKey(UserManagedGroup, related_name='memberships')

    date_added = ...
    membership_justification = ...

递归域应该是不对称的，因为 Member1 招募 Member2 不应该也意味着 Member2 招募 Member1。我更改了一些属性以更清楚地表达关系。您可以在任何要使用 User 的地方使用代理 Member，因为如果需要访问用户对象，您始终可以访问 Member.user。如果这按预期工作，您应该能够对给定的成员 M 执行以下操作:

M.recruiters.all() -> set of other members that have recruited M to groups
M.recruits.all() -> set of other members that M has recruited to groups
M.leaded_groups.all() -> set of groups M leads
M.managed_groups.all() -> set of groups of which M is a member
M.memberships.all() -> set of Membership objects in which M has been recruited
M.recruitments.all() -> set of Membership objects in which M has recruited someone

对于 G 组，

G.memberships.all() -> set of Memberships associated with the group

我认为这应该可行，并提供比单独的 MembershipInfo 模型更“干净”的解决方案，但它可能需要一些调整，例如检查递归字段的方向以确保招聘人员招募新兵，而不是相反。

编辑:我忘记将成员(member)模型链接到用户模型。可以这样完成:

def create_member(member, instance, created, **kwargs):
    if created:
        member, created = Member.objects.get_or_create(user=instance)

post_save.connect(create_member, member=User)

注意create_member不是Member的方法，而是在定义Member之后调用。通过这样做，每当创建用户时，应该自动创建一个成员对象(如果您想在不初始化成员字段的情况下添加用户，您可能需要将成员字段设置为 null=True 和/或空白=True)。