forked from mirrors/bookwyrm
224 lines
7.6 KiB
Python
224 lines
7.6 KiB
Python
""" defines relationships between users """
|
|
from django.apps import apps
|
|
from django.core.cache import cache
|
|
from django.db import models, transaction, IntegrityError
|
|
from django.db.models import Q
|
|
|
|
from bookwyrm import activitypub
|
|
from .activitypub_mixin import ActivitypubMixin, ActivityMixin
|
|
from .activitypub_mixin import generate_activity
|
|
from .base_model import BookWyrmModel
|
|
from . import fields
|
|
|
|
|
|
class UserRelationship(BookWyrmModel):
|
|
"""many-to-many through table for followers"""
|
|
|
|
user_subject = fields.ForeignKey(
|
|
"User",
|
|
on_delete=models.PROTECT,
|
|
related_name="%(class)s_user_subject",
|
|
activitypub_field="actor",
|
|
)
|
|
user_object = fields.ForeignKey(
|
|
"User",
|
|
on_delete=models.PROTECT,
|
|
related_name="%(class)s_user_object",
|
|
activitypub_field="object",
|
|
)
|
|
|
|
@property
|
|
def privacy(self):
|
|
"""all relationships are handled directly with the participants"""
|
|
return "direct"
|
|
|
|
@property
|
|
def recipients(self):
|
|
"""the remote user needs to recieve direct broadcasts"""
|
|
return [u for u in [self.user_subject, self.user_object] if not u.local]
|
|
|
|
def save(self, *args, **kwargs):
|
|
"""clear the template cache"""
|
|
clear_cache(self.user_subject, self.user_object)
|
|
super().save(*args, **kwargs)
|
|
|
|
def delete(self, *args, **kwargs):
|
|
"""clear the template cache"""
|
|
clear_cache(self.user_subject, self.user_object)
|
|
super().delete(*args, **kwargs)
|
|
|
|
class Meta:
|
|
"""relationships should be unique"""
|
|
|
|
abstract = True
|
|
constraints = [
|
|
models.UniqueConstraint(
|
|
fields=["user_subject", "user_object"], name="%(class)s_unique"
|
|
),
|
|
models.CheckConstraint(
|
|
check=~models.Q(user_subject=models.F("user_object")),
|
|
name="%(class)s_no_self",
|
|
),
|
|
]
|
|
|
|
def get_remote_id(self):
|
|
"""use shelf identifier in remote_id"""
|
|
base_path = self.user_subject.remote_id
|
|
return f"{base_path}#follows/{self.id}"
|
|
|
|
|
|
class UserFollows(ActivityMixin, UserRelationship):
|
|
"""Following a user"""
|
|
|
|
status = "follows"
|
|
|
|
def to_activity(self): # pylint: disable=arguments-differ
|
|
"""overrides default to manually set serializer"""
|
|
return activitypub.Follow(**generate_activity(self))
|
|
|
|
def save(self, *args, **kwargs):
|
|
"""really really don't let a user follow someone who blocked them"""
|
|
# blocking in either direction is a no-go
|
|
if UserBlocks.objects.filter(
|
|
Q(
|
|
user_subject=self.user_subject,
|
|
user_object=self.user_object,
|
|
)
|
|
| Q(
|
|
user_subject=self.user_object,
|
|
user_object=self.user_subject,
|
|
)
|
|
).exists():
|
|
raise IntegrityError(
|
|
"Attempting to follow blocked user", self.user_subject, self.user_object
|
|
)
|
|
# don't broadcast this type of relationship -- accepts and requests
|
|
# are handled by the UserFollowRequest model
|
|
super().save(*args, broadcast=False, **kwargs)
|
|
|
|
@classmethod
|
|
def from_request(cls, follow_request):
|
|
"""converts a follow request into a follow relationship"""
|
|
obj, _ = cls.objects.get_or_create(
|
|
user_subject=follow_request.user_subject,
|
|
user_object=follow_request.user_object,
|
|
remote_id=follow_request.remote_id,
|
|
)
|
|
return obj
|
|
|
|
|
|
class UserFollowRequest(ActivitypubMixin, UserRelationship):
|
|
"""following a user requires manual or automatic confirmation"""
|
|
|
|
status = "follow_request"
|
|
activity_serializer = activitypub.Follow
|
|
|
|
def save(self, *args, broadcast=True, **kwargs): # pylint: disable=arguments-differ
|
|
"""make sure the follow or block relationship doesn't already exist"""
|
|
# if there's a request for a follow that already exists, accept it
|
|
# without changing the local database state
|
|
if UserFollows.objects.filter(
|
|
user_subject=self.user_subject,
|
|
user_object=self.user_object,
|
|
).exists():
|
|
self.accept(broadcast_only=True)
|
|
return
|
|
|
|
# blocking in either direction is a no-go
|
|
if UserBlocks.objects.filter(
|
|
Q(
|
|
user_subject=self.user_subject,
|
|
user_object=self.user_object,
|
|
)
|
|
| Q(
|
|
user_subject=self.user_object,
|
|
user_object=self.user_subject,
|
|
)
|
|
).exists():
|
|
raise IntegrityError(
|
|
"Attempting to follow blocked user", self.user_subject, self.user_object
|
|
)
|
|
super().save(*args, **kwargs)
|
|
|
|
if broadcast and self.user_subject.local and not self.user_object.local:
|
|
self.broadcast(self.to_activity(), self.user_subject)
|
|
|
|
if self.user_object.local:
|
|
manually_approves = self.user_object.manually_approves_followers
|
|
if not manually_approves:
|
|
self.accept()
|
|
|
|
model = apps.get_model("bookwyrm.Notification", require_ready=True)
|
|
notification_type = "FOLLOW_REQUEST" if manually_approves else "FOLLOW"
|
|
model.objects.create(
|
|
user=self.user_object,
|
|
related_user=self.user_subject,
|
|
notification_type=notification_type,
|
|
)
|
|
|
|
def get_accept_reject_id(self, status):
|
|
"""get id for sending an accept or reject of a local user"""
|
|
|
|
base_path = self.user_object.remote_id
|
|
status_id = self.id or 0
|
|
return f"{base_path}#{status}/{status_id}"
|
|
|
|
def accept(self, broadcast_only=False):
|
|
"""turn this request into the real deal"""
|
|
user = self.user_object
|
|
if not self.user_subject.local:
|
|
activity = activitypub.Accept(
|
|
id=self.get_accept_reject_id(status="accepts"),
|
|
actor=self.user_object.remote_id,
|
|
object=self.to_activity(),
|
|
).serialize()
|
|
self.broadcast(activity, user)
|
|
if broadcast_only:
|
|
return
|
|
|
|
with transaction.atomic():
|
|
UserFollows.from_request(self)
|
|
if self.id:
|
|
self.delete()
|
|
|
|
def reject(self):
|
|
"""generate a Reject for this follow request"""
|
|
if self.user_object.local:
|
|
activity = activitypub.Reject(
|
|
id=self.get_accept_reject_id(status="rejects"),
|
|
actor=self.user_object.remote_id,
|
|
object=self.to_activity(),
|
|
).serialize()
|
|
self.broadcast(activity, self.user_object)
|
|
|
|
self.delete()
|
|
|
|
|
|
class UserBlocks(ActivityMixin, UserRelationship):
|
|
"""prevent another user from following you and seeing your posts"""
|
|
|
|
status = "blocks"
|
|
activity_serializer = activitypub.Block
|
|
|
|
def save(self, *args, **kwargs):
|
|
"""remove follow or follow request rels after a block is created"""
|
|
super().save(*args, **kwargs)
|
|
|
|
UserFollows.objects.filter(
|
|
Q(user_subject=self.user_subject, user_object=self.user_object)
|
|
| Q(user_subject=self.user_object, user_object=self.user_subject)
|
|
).delete()
|
|
UserFollowRequest.objects.filter(
|
|
Q(user_subject=self.user_subject, user_object=self.user_object)
|
|
| Q(user_subject=self.user_object, user_object=self.user_subject)
|
|
).delete()
|
|
|
|
|
|
def clear_cache(user_subject, user_object):
|
|
"""clear relationship cache"""
|
|
cache.delete_many(
|
|
[
|
|
f"relationship-{user_subject.id}-{user_object.id}",
|
|
f"relationship-{user_object.id}-{user_subject.id}",
|
|
]
|
|
)
|