Use ActivityPub models for external videos

pod/activitypub/README.md

@@ -137,5 +137,5 @@ curl -H "Accept: application/activity+json, application/ld+json" -s "http://pod.
 ### Unit tests
 
 ```shell
-python manage.py test --settings=pod.main.test_settings pod.activitypub.test_settings
+python manage.py test --settings=pod.main.test_settings pod.activitypub.tests
 ```

pod/activitypub/admin.py

@@ -1,7 +1,7 @@
 from django.contrib import admin
 from django.utils.translation import gettext_lazy as _
 
-from .models import Follower, Following
+from .models import Follower, Following, ExternalVideo
 from .tasks import task_follow, task_index_videos
 
 
@@ -27,4 +27,33 @@ def reindex_videos(modeladmin, request, queryset):
 @admin.register(Following)
 class FollowingAdmin(admin.ModelAdmin):
     actions = [send_federation_request, reindex_videos]
-    list_display = ("object", "status")
+    list_display = (
+        "object",
+        "status",
+    )
+
+
+# TODO External video admin
+@admin.register(ExternalVideo)
+class ExternalVideoAdmin(admin.ModelAdmin):
+    list_display = (
+        "id",
+        "title",
+        "source_instance",
+        "date_added",
+        "viewcount",
+        "duration_in_time",
+        "get_thumbnail_admin",
+    )
+    list_display_links = ("id", "title")
+    list_filter = (
+        "date_added",
+    )
+
+    search_fields = [
+        "id",
+        "title",
+        "video",
+        "source_instance__object",
+    ]
+    list_per_page = 20

pod/activitypub/apps.py

@@ -1,5 +1,5 @@
 from django.apps import AppConfig
-from django.db.models.signals import post_delete, post_save
+from django.db.models.signals import post_delete, pre_save, post_save
 
 
 class ActivitypubConfig(AppConfig):
@@ -9,7 +9,8 @@ class ActivitypubConfig(AppConfig):
     def ready(self):
         from pod.video.models import Video
 
-        from .signals import on_video_delete, on_video_save
+        from .signals import on_video_delete, on_video_save, on_video_pre_save
 
+        pre_save.connect(on_video_pre_save, sender=Video)
         post_save.connect(on_video_save, sender=Video)
         post_delete.connect(on_video_delete, sender=Video)

pod/activitypub/context_processors.py

@@ -0,0 +1,12 @@
+from pod.activitypub.models import ExternalVideo
+
+
+def get_available_external_videos_filter(request=None):
+    """Return the base filter to get the available external videos of the site."""
+
+    return ExternalVideo.objects.filter()
+
+
+def get_available_external_videos(request=None):
+    """Get all external videos available."""
+    return get_available_external_videos_filter(request).distinct()

pod/activitypub/models.py

@@ -1,7 +1,12 @@
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
+from django.template.defaultfilters import slugify
+from django.utils.html import format_html
+from django.urls import reverse
 
-from pod.video.models import Video
+
+from pod.video.models import BaseVideo
+from pod.main.models import get_nextautoincrement
 
 
 class Follower(models.Model):
@@ -31,8 +36,11 @@ class Status(models.IntegerChoices):
         default=Status.NONE,
     )
 
+    def __str__(self) -> str:
+        return self.object
+
 
-class ExternalVideo(Video):
+class ExternalVideo(BaseVideo):
     source_instance = models.ForeignKey(
         Following,
         on_delete=models.CASCADE,
@@ -43,4 +51,68 @@ class ExternalVideo(Video):
         _("Video identifier"),
         max_length=255,
         help_text=_("Video identifier URL"),
+        unique=True,
+    )
+    video = models.CharField(
+        _("Video source"),
+        max_length=255,
+        help_text=_("Video source URL"),
     )
+    thumbnail = models.CharField(
+        _("Thumbnails"),
+        max_length=255,
+        blank=True,
+        null=True,
+    )
+    viewcount = models.IntegerField(_("Number of view"), default=0)
+
+    def save(self, *args, **kwargs) -> None:
+        """Store an external video object in db."""
+        newid = -1
+
+        # In case of creating new Video
+        if not self.id:
+            # previous_video_state = None
+            try:
+                newid = get_nextautoincrement(ExternalVideo)
+            except Exception:
+                try:
+                    newid = ExternalVideo.objects.latest("id").id
+                    newid += 1
+                except Exception:
+                    newid = 1
+        else:
+            # previous_video_state = Video.objects.get(id=self.id)
+            newid = self.id
+        newid = "%04d" % newid
+        self.slug = "%s-%s" % (newid, slugify(self.title))
+        self.is_external = True
+        super(ExternalVideo, self).save(*args, **kwargs)
+
+    @property
+    def get_thumbnail_admin(self):
+        return format_html(
+            '<img style="max-width:100px" '
+            'src="%s" alt="%s" loading="lazy">'
+            % (
+                self.thumbnail,
+                self.title,
+            )
+        )
+
+    def get_thumbnail_card(self) -> str:
+        """Return thumbnail image card of current external video."""
+        return (
+            '<img class="pod-thumbnail" src="%s" alt="%s"\
+            loading="lazy">'
+            % (self.thumbnail, self.title)
+        )
+
+    get_thumbnail_admin.fget.short_description = _("Thumbnails")
+
+    def get_absolute_url(self) -> str:
+        """Get the external video absolute URL."""
+        return reverse("activitypub:external_video", args=[str(self.slug)])
+
+    def get_marker_time_for_user(video, user):  # TODO: Check usage
+        return 0

pod/activitypub/network.py

@@ -8,6 +8,7 @@
 
 from pod.activitypub.utils import ap_object
 from pod.video.models import Video
+from pod.activitypub.models import ExternalVideo
 
 from .constants import AP_DEFAULT_CONTEXT, AP_PT_VIDEO_CONTEXT, BASE_HEADERS
 from .models import Follower, Following
@@ -98,9 +99,7 @@ def index_video(following: Following, video_url):
     """Read a video payload and create an ExternalVideo object"""
     ap_video = ap_object(video_url)
     logger.warning(f"TODO: Deal with video indexation {ap_video}")
-    extvideo = ap_video_to_external_video(ap_video)
-    extvideo.source_instance = following
-    extvideo.save()
+    ap_video_to_external_video(payload=ap_video, source_instance=following)
 
 
 def external_video_added_by_actor(ap_video, ap_actor):

pod/activitypub/serialization/video.py

@@ -1,15 +1,61 @@
 from django.template.defaultfilters import slugify
 from django.urls import reverse
 from markdownify import markdownify
+from django.utils.translation import get_language
 
 from pod.activitypub.constants import AP_LICENSE_MAPPING
 from pod.activitypub.models import ExternalVideo
 from pod.activitypub.utils import ap_url, make_magnet_url, stable_uuid
+from pod.video.models import LANG_CHOICES
 
+import logging
+logger = logging.getLogger(__name__)
 
-def ap_video_to_external_video(payload):
+
+def ap_video_to_external_video(payload, source_instance):
     """Create an ExternalVideo object from an AP Video payload."""
-    return ExternalVideo.objects.create()
+
+    video_source_links = [link for link in payload["url"] if "mediaType" in link and link["mediaType"] == "video/mp4"]
+    if not video_source_links:
+        tags = []
+        for link in payload["url"]:
+            if "tag" in link:
+                tags.extend(link["tag"])
+        video_source_links = [link for link in tags if "mediaType" in link and link["mediaType"] == "video/mp4"]
+
+    external_video_attributes = {
+        "ap_id": payload["id"],
+        "video": video_source_links[0]["href"],
+        "title": payload["name"],
+        "date_added": payload["published"],
+        "thumbnail": [icon for icon in payload["icon"] if "thumbnails" in icon["url"]][0]["url"],
+        "duration": int(payload["duration"].lstrip("PT").rstrip("S")),
+        "viewcount": payload["views"],
+        "source_instance": source_instance,
+    }
+
+    if (
+        "language" in payload
+        and "identifier" in payload["language"]
+        and (identifier := payload["language"]["identifier"])
+        and identifier in LANG_CHOICES
+    ):
+        external_video_attributes["main_lang"] = identifier
+
+    if "content" in payload and (content := payload["content"]):
+        external_video_attributes["description"] = content
+
+    external_video, created = ExternalVideo.objects.update_or_create(
+        ap_id=external_video_attributes["ap_id"],
+        defaults=external_video_attributes,
+    )
+
+    if created:
+        logger.info("ActivityPub external video %s created from %s instance", external_video, source_instance)
+    else:
+        logger.info("ActivityPub external video %s updated from %s instance", external_video, source_instance)
+
+    return external_video
 
 
 def video_to_ap_video(video):
@@ -125,8 +171,16 @@ def video_urls(video):
     magnets may become fully optional someday
     https://framacolibri.org/t/comments-and-suggestions-on-the-peertube-activitypub-implementation/21215/2
     """
-
-    return {
+    truc = video.get_video_mp4()
+    # print(video)
+    # print(dir(truc[0]))
+    # print(truc[0].id)
+    # print(truc[0].pk)
+    # print(truc[0].source_file.url)
+    # print(truc[0].source_file.file)
+    # print(type(truc[0].source_file))
+    # print(dir(truc[0].source_file))
+    machin = {
         "url": (
             [
                 # Webpage
@@ -141,7 +195,11 @@ def video_urls(video):
                 {
                     "type": "Link",
                     "mediaType": mp4.encoding_format,
-                    "href": ap_url(mp4.source_file.url),
+                    # "href": ap_url(mp4.source_file.url),
+                    "href": ap_url(reverse(
+                        "video:video_mp4",
+                        kwargs={"id": video.id, "mp4_id": mp4.id},
+                    )),
                     "height": mp4.height,
                     "width": mp4.width,
                     "size": mp4.source_file.size,
@@ -165,6 +223,8 @@ def video_urls(video):
             ]
         )
     }
+    print(machin)
+    return machin
 
 
 def video_attributions(video):
@@ -370,16 +430,16 @@ def video_icon(video):
     # only image/jpeg is supported on peertube
     # https://github.com/Chocobozzz/PeerTube/blob/b824480af7054a5a49ddb1788c26c769c89ccc8a/server/core/helpers/custom-validators/activitypub/videos.ts#L192
     """
-    if not video.thumbnail:
-        return {}
+    # if not video.thumbnail:
+    #     return {}
 
     return {
         "icon": [
             {
                 "type": "Image",
-                "url": video.get_thumbnail_url(scheme=True),
-                "width": video.thumbnail.file.width,
-                "height": video.thumbnail.file.height,
+                "url": video.get_thumbnail_url(scheme=True, is_activity_pub=True),
+                "width": video.thumbnail.file.width if video.thumbnail else 640,
+                "height": video.thumbnail.file.height if video.thumbnail else 360,
                 # TODO: use the real media type when peertub supports JPEG
                 # "mediaType": video.thumbnail.file_type,
                 "mediaType": "image/jpeg",