Merge pull request #87 from dtinit/refactor-follow-activities-and-test-data-previously

Refactor follow activities and test data previously

Author: aaronjae22

testbed/core/factories.py

@@ -32,9 +32,9 @@ class Meta:
         model = Actor
 
     user = factory.SubFactory(UserFactory)
-    username = factory.SelfAttribute("user.username")
-    full_name = factory.Faker("name")
-    previously = factory.Dict({})
+    username = factory.SelfAttribute('user.username')
+    full_name = factory.Faker('name')
+    previously = factory.List([])
 
 
 class NoteFactory(DjangoModelFactory):

testbed/core/management/commands/seed.py

@@ -4,7 +4,7 @@
 from django.contrib.auth import get_user_model
 from django.conf import settings
 from django.utils import timezone
-from testbed.core.models import LikeActivity
+from testbed.core.models import LikeActivity, FollowActivity
 from testbed.core.factories import (
     ActorFactory,
     CreateActivityFactory,
@@ -57,6 +57,39 @@ def create_remote_like(self, actor):
             visibility="public",
         )
 
+    def create_remote_follow(self, actor):
+        server, usernames = random.choice(REMOTE_SERVERS)
+        username = random.choice(usernames)
+
+        return FollowActivity.objects.create(
+            actor=actor,
+            target_actor=None,
+            target_actor_url=f"https://{server}/users/{username}",
+            target_actor_data={
+                "type": "Person",
+                "preferredUsername": username,
+                "name": username,
+                "url": f"https://{server}/users/{username}",
+            },
+            visibility="public"
+        )
+
+    # Create actor with previous server history
+    def create_actor_with_history(self):
+        actor = ActorFactory.create()
+
+        # Add 1-2 previous servers
+        num_previous = random.randint(1, 2)
+
+        for _ in range(num_previous):
+            server, usernames = random.choice(REMOTE_SERVERS)
+            username = random.choice(usernames)
+            move_date = timezone.now() - timedelta(days=random.randint(30, 365)) 
+
+            actor.record_move(server, username, move_date)
+
+        return actor
+
     def handle(self, *args, **kwargs):
         try:
             # Check if seeding is allowed in current environment
@@ -104,15 +137,22 @@ def handle(self, *args, **kwargs):
                             self.style.WARNING("Skipping admin user creation.")
                         )
             else:
-                self.stdout.write(self.style.SUCCESS("Admin user already exists."))
-
-            # Create multiple actors (Outbox will be created automatically)
-            self.stdout.write("Creating actors...")
-            actors = ActorFactory.create_batch(10)
-
-            # Track different types of likes
+                self.stdout.write(self.style.SUCCESS('Admin user already exists.'))
+            
+            # Create multiple actors - mix of regular and those with history
+            # (Outbox will be created automatically)
+            self.stdout.write('Creating actors...')
+            regular_actors = ActorFactory.create_batch(7) # 7 regular actors
+            history_actors = [self.create_actor_with_history() for _ in range(3)] # 3 actors with history
+            actors = regular_actors + history_actors
+
+            # Track different types of activities
             local_like_count = 0
             remote_like_count = 0
+            local_follow_count = 0
+            remote_follow_count = 0
+            moved_actors_count = len(history_actors) # Counts the number of actors with history
+            regular_actors_count = len(regular_actors) # Counts the number of regular actors
 
             # Create notes and various activities
             self.stdout.write("Creating notes and activities...")
@@ -142,30 +182,40 @@ def handle(self, *args, **kwargs):
                     actor.portability_outbox.first().add_activity(remote_like)
                     remote_like_count += 1
 
-                # Create some follow relationships
-                for _ in range(2):  # Each actor follows 2 other actors
+                # Create local follows
+                for _ in range(1): # Each actor follows 1 local actor
+
                     target = random.choice([a for a in actors if a != actor])
                     follow_activity = FollowActivityFactory(
                         actor=actor, target_actor=target, visibility="public"
                     )
                     actor.portability_outbox.first().add_activity(follow_activity)
+                    local_follow_count += 1
+
+                # Create remote follows
+                for _ in range(1): # Each actor follows 1 remote actor
+                    remote_follow = self.create_remote_follow(actor)
+                    actor.portability_outbox.first().add_activity(remote_follow)
+                    remote_follow_count += 1
 
             # Count all activities
             total_actors = len(actors)
             total_notes = len(actors) * 3
-            total_creates = total_notes + total_actors  # Notes + Actor creates
-            total_follows = len(actors) * 2
+            total_creates = total_notes + total_actors # Notes + Actor creates
 
             self.stdout.write(
                 self.style.SUCCESS(
-                    f"Successfully created:\n"
-                    f"- {total_actors} actors\n"
-                    f"- {total_notes} notes\n"
-                    f"- {total_creates} Create activities ({total_actors} for actors, {total_notes} for notes)\n"
-                    f"- {local_like_count} Local Like activities\n"
-                    f"- {remote_like_count} Remote Like activities\n"
-                    f"- {total_follows} Follow activities\n\n"
-                    f"Federation seeding created with servers: f{','.join(server for server, _ in REMOTE_SERVERS)}"
+                    f'Successfully created:\n'
+                    f'- {total_actors} actors\n'
+                    f'- {moved_actors_count} actors with history\n'
+                    f'- {regular_actors_count} regular actors\n'
+                    f'- {total_notes} notes\n'
+                    f'- {total_creates} Create activities ({total_actors} for actors, {total_notes} for notes)\n'
+                    f'- {local_like_count} Local Like activities\n'
+                    f'- {remote_like_count} Remote Like activities\n'
+                    f'- {local_follow_count} Local Follow activities\n'
+                    f'- {remote_follow_count} Remote Follow activities\n\n'
+                    f'Federation seeding created with servers: {", ".join(server for server, _ in REMOTE_SERVERS)}' 
                 )
             )
 

testbed/core/migrations/0004_followactivity_target_actor_data_and_more.py

@@ -0,0 +1,29 @@
+# Generated by Django 5.1.3 on 2025-03-19 16:33
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0003_likeactivity_object_data_likeactivity_object_url_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='followactivity',
+            name='target_actor_data',
+            field=models.JSONField(blank=True, help_text='Metadata of the followed actor', null=True),
+        ),
+        migrations.AddField(
+            model_name='followactivity',
+            name='target_actor_url',
+            field=models.URLField(blank=True, help_text='URL of the followed actor in the fediverse', null=True),
+        ),
+        migrations.AlterField(
+            model_name='followactivity',
+            name='target_actor',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='follow_activities_received', to='core.actor'),
+        ),
+    ]

testbed/core/migrations/0005_alter_actor_previously.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.3 on 2025-03-19 22:16
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0004_followactivity_target_actor_data_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='actor',
+            name='previously',
+            field=models.JSONField(blank=True, default=list, null=True),
+        ),
+    ]

testbed/core/models.py

@@ -2,6 +2,7 @@
 from django.db import models
 from django.contrib.auth.models import User
 from django.core.exceptions import ValidationError
+from datetime import timezone
 
 logger = logging.getLogger(__name__)
 
@@ -22,11 +23,28 @@ class Actor(models.Model):
     full_name = models.CharField(max_length=100)
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
-    previously = models.JSONField(default=dict, null=True, blank=True)
+    previously = models.JSONField(default=list, null=True, blank=True)
 
     def __str__(self):
         return self.username
+    
+    # Record a previous location of this account
+    def record_move(self, previous_server, previous_username, move_date=None):
+        print(f"Previously type: {type(self.previously)}")  # Debug line
+        print(f"Previously value: {self.previously}")       # Debug line
+
+        if self.previously is None:
+            self.previously = []
+
+        move_record = {
+            'type': 'Move', 
+            'object': f"https://{previous_server}/users/{previous_username}",
+            'published': (move_date or timezone.now()).isoformat()
+        }
 
+        self.previously.append(move_record)
+        self.save()
+    
     def save(self, *args, **kwargs):
         is_new = self._state.adding
         super().save(*args, **kwargs)
@@ -60,7 +78,7 @@ def get_json_ld(self):
             "id": f"https://example.com/users/{self.username}",
             "preferredUsername": self.username,
             "name": self.username,
-            "previously": self.previously,
+            "previously": self.previously or [], # Ensure it's always a list
         }
 
 
@@ -171,23 +189,55 @@ def get_json_ld(self):
 
 class FollowActivity(Activity):
     target_actor = models.ForeignKey(
-        Actor, on_delete=models.CASCADE, related_name="follow_activities_received"
+        Actor,
+        on_delete=models.CASCADE,
+        related_name="follow_activities_received",
+        null=True,
+        blank=True
+    )
+    target_actor_url = models.URLField(
+        max_length=200,
+        help_text="URL of the followed actor in the fediverse",
+        null=True,
+        blank=True
+    )
+    target_actor_data = models.JSONField(
+        help_text="Metadata of the followed actor",
+        null=True,
+        blank=True,
     )
 
-    def __str__(self):
-        return f"Follow by {self.actor.username}: {self.target_actor.username}"
+    def clean(self):
+        super().clean()
+        if not self.target_actor and not (self.target_actor_url and self.target_actor_data):
+            raise ValidationError("Either local target_actor or remote actor data (URL and metadata) must be provided")
 
+    def __str__(self):
+        if self.target_actor:
+            return f'Follow by {self.actor.username}: {self.target_actor.username}'
+        username = self.target_actor_data.get('preferredUsername', '')
+        return f'Follow by {self.actor.username}: {username} (remote)'
+    
     def get_json_ld(self):
-        return {
+        base = {
             "@context": "https://www.w3.org/ns/activitystreams",
             "type": "Follow",
             "id": f"https://example.com/activities/{self.id}",
             "actor": f"https://example.com/users/{self.actor.username}",
-            "object": self.target_actor.get_json_ld(),
             "published": self.timestamp.isoformat(),
             "visibility": self.visibility,
         }
 
+        if self.target_actor:
+            base["object"] = self.target_actor.get_json_ld()
+        else:
+            base["object"] = {
+                "@context": "https://www.w3.org/ns/activitystreams",
+                **self.target_actor_data,
+                "id": self.target_actor_url
+            }
+
+        return base
 
 class Note(models.Model):
     actor = models.ForeignKey(Actor, on_delete=models.CASCADE, related_name="notes")