在 django 中，任何用户都可以阻止任何用户，如果他们被阻止，他们就看不到被阻止用户的帖子，也找不到他们[关闭]

Question

在我制作的 django 中，用户可以互相关注并获得他们关注的用户的帖子。我现在想实现一个阻止系统，这样任何用户都可以阻止另一个用户，并且被阻止的用户无法看到阻止他们的用户的个人资料或帖子

我的models.py：

class post(models.Model):
title = models.CharField(max_length=100)
image = models.ImageField(upload_to='post_pics', null=True, blank=True)
video = models.FileField(upload_to='post_videos', null=True, blank=True)
content = models.TextField()
likes = models.ManyToManyField(User, related_name='likes', blank=True)
date_posted = models.DateTimeField(default=timezone.now)
author = models.ForeignKey(User, on_delete=models.CASCADE)

objects = postManager()

def __str__(self):
    return self.title

class Meta:
    ordering = ['-date_posted', 'title']

def get_absolute_url(self):
        return reverse ('blog-home')

def total_likes(self):
    return self.likes.count()

class UserProfileManager(models.Manager):
use_for_related_fields = True
def all(self):
    qs = self.get_queryset().all()
    try:
        if self.instance:
            qs = qs.exclude(user=self.instance)
    except:
        pass
    return qs

def toggle_follow(self, user, to_toggle_user):
    user_profile, created = UserProfile.objects.get_or_create(user=user)
    if to_toggle_user in user_profile.following.all():
       user_profile.following.remove(to_toggle_user)
       added = False
    else:
       user_profile.following.add(to_toggle_user)
       added = True
    return added

def is_following(self, user, followed_by_user):
    user_profile, created = UserProfile.objects.get_or_create(user=user)
    if created:
        return False
    if followed_by_user in user_profile.following.all():
        return True
    return False


class UserProfile(models.Model):
user      = models.OneToOneField(settings.AUTH_USER_MODEL, related_name='owner', on_delete=models.CASCADE)
following = models.ManyToManyField(settings.AUTH_USER_MODEL, blank=True, related_name='followed_by')

objects = UserProfileManager()

def __str__(self):
    return str(self.following.all().count())

def get_following(self):
    users = self.following.all()
    return users.exclude(username=self.user.username)

Answer 1

我认为可能有两种不同的方法，首先你有一个自定义的用户模型或配置文件。所以向这个模型添加一个新字段，它是'self'（用户模型本身）的 may_to_many 字段，它是被阻止的用户 id 持有者。 实现起来很简单。

class Profile(models.Model):
    .......
    blocked_users = many_to_many_field(User, related_name="blocked_by")

第二个想法是创建一个新模型，对User模型有一个外键，并且又和User模型有一个多对多的关系。

class Blocked(models.Model):
    user = foreign_key_field(User, related_name="blocked_users", ....)
     usres = many_to_many_field(User, related_name="blocked_by" )

所以你可以这样调用：

user.blocked_users.users.all()

现在您可以访问一个用户blocked_users，因此通过在query_set 上使用过滤器，彼此忽略blocked_users。

from django.db.models import Q
# to ignore user X's blocked users posts
blocked_users = User.objects.get(username=X).blocked_users.users.all()
Post.objects.filter(~Q(author__in=blocked_users))