3

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

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

这些是我目前的模型：

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此外，MembershipInfos 的生命与其绑定Membership（这就是我必须创建这个 post_delete 信号连接的原因）。

因为这个，我不能合并它们：

您的中间模型必须包含一个 - 并且只有一个 - 目标模型的外键（在我们的示例中为 Person）。如果您有多个外键，则会引发验证错误。

（在我的情况下，我不能对用户使用 2 个外键）

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

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

4

2 回答 2

5

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

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指向中间模型的属性。我认为也有必要为每个外键分配一个唯一的related_name. 如果您希望递归关系是单向的，则该symmetrical=False参数适用于递归关系，例如 Node1 向 Node2 发送信号，但 Node2 不一定向 Node1 发送信号。symmetrical=False为了使递归多对多使用自定义“通过”模型，有必要定义关系。如果您想使用自定义“通过”模型创建对称递归多对多，可以在此处找到建议。

我发现所有这些相互关系都相当混乱，所以我花了一些时间来选择合理的模型属性和相关名称来实际捕捉代码正在做什么。为了阐明这是如何工作的，如果我有一个节点对象 N，则分别调用N.receivers.all()或N.senders.all()返回从 N 接收数据或向 N 发送数据的其他节点集。通过 related_names调用N.outgoing.all()或N.incoming.all()访问 Connection 对象本身。请注意，这仍然存在一些歧义，senders可以receivers在 ManyToManyField 中交换，代码同样可以正常工作，但方向相反。我通过检查“发送者”是否实际发送给“接收者”或反之亦然的测试用例得出上述结论。

在您的情况下，将两个外键都定位到 User 会增加复杂性，因为如何直接将递归 ManyToManyField 添加到 User 并不明显。我认为自定义用户模型的首选方法是通过一个通过 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，因为如果您需要访问 user 对象，您始终可以访问 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 模型链接到 User 模型。这将是这样的：

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）。

于 2013-05-01T04:02:19.370 回答
2

我看到的最简单的方法是从 UserManagedGroup 中删除 ManyToMany 字段并合并 Membership 和 MembershipInfo。

您还可以使用 entry_set 字段访问您的成员。

于 2013-04-30T17:45:33.500 回答