summaryrefslogtreecommitdiffstats
path: root/users/models/follow.py
blob: 0236d1982cf51e9eb3d1f2745a1a2307c40190bd (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
from typing import Optional

from django.db import models

from core.ld import canonicalise
from core.signatures import HttpSignature
from stator.models import State, StateField, StateGraph, StatorModel
from users.models.identity import Identity


class FollowStates(StateGraph):
    unrequested = State(try_interval=300)
    local_requested = State(try_interval=24 * 60 * 60)
    remote_requested = State(try_interval=24 * 60 * 60)
    accepted = State(externally_progressed=True)
    undone_locally = State(try_interval=60 * 60)
    undone_remotely = State()

    unrequested.transitions_to(local_requested)
    unrequested.transitions_to(remote_requested)
    local_requested.transitions_to(accepted)
    remote_requested.transitions_to(accepted)
    accepted.transitions_to(undone_locally)
    undone_locally.transitions_to(undone_remotely)

    @classmethod
    async def handle_unrequested(cls, instance: "Follow"):
        """
        Follows that are unrequested need us to deliver the Follow object
        to the target server.
        """
        follow = await instance.afetch_full()
        # Remote follows should not be here
        if not follow.source.local:
            return cls.remote_requested
        # Sign it and send it
        await HttpSignature.signed_request(
            uri=follow.target.inbox_uri,
            body=canonicalise(follow.to_ap()),
            private_key=follow.source.private_key,
            key_id=follow.source.public_key_id,
        )
        return cls.local_requested

    @classmethod
    async def handle_local_requested(cls, instance: "Follow"):
        # TODO: Resend follow requests occasionally
        pass

    @classmethod
    async def handle_remote_requested(cls, instance: "Follow"):
        """
        Items in remote_requested need us to send an Accept object to the
        source server.
        """
        follow = await instance.afetch_full()
        await HttpSignature.signed_request(
            uri=follow.source.inbox_uri,
            body=canonicalise(follow.to_accept_ap()),
            private_key=follow.target.private_key,
            key_id=follow.target.public_key_id,
        )
        return cls.accepted

    @classmethod
    async def handle_undone_locally(cls, instance: "Follow"):
        """
        Delivers the Undo object to the target server
        """
        follow = await instance.afetch_full()
        await HttpSignature.signed_request(
            uri=follow.target.inbox_uri,
            body=canonicalise(follow.to_undo_ap()),
            private_key=follow.source.private_key,
            key_id=follow.source.public_key_id,
        )
        return cls.undone_remotely


class Follow(StatorModel):
    """
    When one user (the source) follows other (the target)
    """

    source = models.ForeignKey(
        "users.Identity",
        on_delete=models.CASCADE,
        related_name="outbound_follows",
    )
    target = models.ForeignKey(
        "users.Identity",
        on_delete=models.CASCADE,
        related_name="inbound_follows",
    )

    uri = models.CharField(blank=True, null=True, max_length=500)
    note = models.TextField(blank=True, null=True)

    state = StateField(FollowStates)

    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

    class Meta:
        unique_together = [("source", "target")]

    def __str__(self):
        return f"#{self.id}: {self.source}{self.target}"

    ### Alternate fetchers/constructors ###

    @classmethod
    def maybe_get(cls, source, target) -> Optional["Follow"]:
        """
        Returns a follow if it exists between source and target
        """
        try:
            return Follow.objects.get(source=source, target=target)
        except Follow.DoesNotExist:
            return None

    @classmethod
    def create_local(cls, source, target):
        """
        Creates a Follow from a local Identity to the target
        (which can be local or remote).
        """
        if not source.local:
            raise ValueError("You cannot initiate follows from a remote Identity")
        try:
            follow = Follow.objects.get(source=source, target=target)
        except Follow.DoesNotExist:
            follow = Follow.objects.create(source=source, target=target, uri="")
            follow.uri = source.actor_uri + f"follow/{follow.pk}/"
            # TODO: Local follow approvals
            if target.local:
                follow.state = FollowStates.accepted
            follow.save()
        return follow

    ### Async helpers ###

    async def afetch_full(self):
        """
        Returns a version of the object with all relations pre-loaded
        """
        return await Follow.objects.select_related(
            "source", "source__domain", "target"
        ).aget(pk=self.pk)

    ### ActivityPub (outbound) ###

    def to_ap(self):
        """
        Returns the AP JSON for this object
        """
        return {
            "type": "Follow",
            "id": self.uri,
            "actor": self.source.actor_uri,
            "object": self.target.actor_uri,
        }

    def to_accept_ap(self):
        """
        Returns the AP JSON for this objects' accept.
        """
        return {
            "type": "Accept",
            "id": self.uri + "#accept",
            "actor": self.target.actor_uri,
            "object": self.to_ap(),
        }

    def to_undo_ap(self):
        """
        Returns the AP JSON for this objects' undo.
        """
        return {
            "type": "Undo",
            "id": self.uri + "#undo",
            "actor": self.source.actor_uri,
            "object": self.to_ap(),
        }

    ### ActivityPub (inbound) ###

    @classmethod
    def by_ap(cls, data, create=False) -> "Follow":
        """
        Retrieves a Follow instance by its ActivityPub JSON object.

        Optionally creates one if it's not present.
        Raises KeyError if it's not found and create is False.
        """
        # Resolve source and target and see if a Follow exists
        source = Identity.by_actor_uri(data["actor"], create=create)
        target = Identity.by_actor_uri(data["object"])
        follow = cls.maybe_get(source=source, target=target)
        # If it doesn't exist, create one in the remote_requested state
        if follow is None:
            if create:
                return cls.objects.create(
                    source=source,
                    target=target,
                    uri=data["id"],
                    state=FollowStates.remote_requested,
                )
            else:
                raise KeyError(
                    f"No follow with source {source} and target {target}", data
                )
        else:
            return follow

    @classmethod
    def handle_request_ap(cls, data):
        """
        Handles an incoming follow request
        """
        follow = cls.by_ap(data, create=True)
        # Force it into remote_requested so we send an accept
        follow.transition_perform(FollowStates.remote_requested)

    @classmethod
    def handle_accept_ap(cls, data):
        """
        Handles an incoming Follow Accept for one of our follows
        """
        # Ensure the Accept actor is the Follow's object
        if data["actor"] != data["object"]["object"]:
            raise ValueError("Accept actor does not match its Follow object", data)
        # Resolve source and target and see if a Follow exists (it really should)
        try:
            follow = cls.by_ap(data["object"])
        except KeyError:
            raise ValueError("No Follow locally for incoming Accept", data)
        # If the follow was waiting to be accepted, transition it
        if follow and follow.state in [
            FollowStates.unrequested,
            FollowStates.local_requested,
        ]:
            follow.transition_perform(FollowStates.accepted)

    @classmethod
    def handle_undo_ap(cls, data):
        """
        Handles an incoming Follow Undo for one of our follows
        """
        # Ensure the Undo actor is the Follow's actor
        if data["actor"] != data["object"]["actor"]:
            raise ValueError("Undo actor does not match its Follow object", data)
        # Resolve source and target and see if a Follow exists (it hopefully does)
        try:
            follow = cls.by_ap(data["object"])
        except KeyError:
            raise ValueError("No Follow locally for incoming Undo", data)
        # Delete the follow
        follow.delete()