moviewyrm/bookwyrm/models/base_model.py

''' base model with default fields '''
from datetime import datetime
from base64 import b64encode
from dataclasses import dataclass
from typing import Callable
from uuid import uuid4
from urllib.parse import urlencode

from Crypto.PublicKey import RSA
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256
from django.db import models
from django.dispatch import receiver

from bookwyrm import activitypub
from bookwyrm.settings import DOMAIN


PrivacyLevels = models.TextChoices('Privacy', [
    'public',
    'unlisted',
    'followers',
    'direct'
])

class BookWyrmModel(models.Model):
    ''' shared fields '''
    created_date = models.DateTimeField(auto_now_add=True)
    updated_date = models.DateTimeField(auto_now=True)
    remote_id = models.CharField(max_length=255, null=True)

    def get_remote_id(self):
        ''' generate a url that resolves to the local object '''
        base_path = 'https://%s' % DOMAIN
        if hasattr(self, 'user'):
            base_path = self.user.remote_id
        model_name = type(self).__name__.lower()
        return '%s/%s/%d' % (base_path, model_name, self.id)

    class Meta:
        ''' this is just here to provide default fields for other models '''
        abstract = True


@receiver(models.signals.post_save)
def execute_after_save(sender, instance, created, *args, **kwargs):
    ''' set the remote_id after save (when the id is available) '''
    if not created or not hasattr(instance, 'get_remote_id'):
        return
    if not instance.remote_id:
        instance.remote_id = instance.get_remote_id()
        instance.save()


class ActivitypubMixin:
    ''' add this mixin for models that are AP serializable '''
    activity_serializer = lambda: {}

    def to_activity(self, pure=False):
        ''' convert from a model to an activity '''
        if pure:
            mappings = self.pure_activity_mappings
        else:
            mappings = self.activity_mappings

        fields = {}
        for mapping in mappings:
            if not hasattr(self, mapping.model_key) or not mapping.activity_key:
                continue
            value = getattr(self, mapping.model_key)
            if hasattr(value, 'local_id'):
                value = value.local_id
            elif hasattr(value, 'remote_id'):
                value = value.remote_id
            if isinstance(value, datetime):
                value = value.isoformat()
            fields[mapping.activity_key] = mapping.activity_formatter(value)

        if pure:
            return self.pure_activity_serializer(
                **fields
            ).serialize()
        return self.activity_serializer(
            **fields
        ).serialize()


    def to_create_activity(self, user, pure=False):
        ''' returns the object wrapped in a Create activity '''
        activity_object = self.to_activity(pure=pure)

        signer = pkcs1_15.new(RSA.import_key(user.private_key))
        content = activity_object['content']
        signed_message = signer.sign(SHA256.new(content.encode('utf8')))
        create_id = self.remote_id + '/activity'

        signature = activitypub.Signature(
            creator='%s#main-key' % user.remote_id,
            created=activity_object['published'],
            signatureValue=b64encode(signed_message).decode('utf8')
        )

        return activitypub.Create(
            id=create_id,
            actor=user.remote_id,
            to=['%s/followers' % user.remote_id],
            cc=['https://www.w3.org/ns/activitystreams#Public'],
            object=activity_object,
            signature=signature,
        ).serialize()


    def to_delete_activity(self, user):
        ''' notice of deletion '''
        # this should be a tombstone
        activity_object = self.to_activity()

        return activitypub.Delete(
            id=self.remote_id + '/activity',
            actor=user.remote_id,
            to=['%s/followers' % user.remote_id],
            cc=['https://www.w3.org/ns/activitystreams#Public'],
            object=activity_object,
        ).serialize()


    def to_update_activity(self, user):
        ''' wrapper for Updates to an activity '''
        activity_id = '%s#update/%s' % (user.remote_id, uuid4())
        return activitypub.Update(
            id=activity_id,
            actor=user.remote_id,
            to=['https://www.w3.org/ns/activitystreams#Public'],
            object=self.to_activity()
        ).serialize()


    def to_undo_activity(self, user):
        ''' undo an action '''
        return activitypub.Undo(
            id='%s#undo' % user.remote_id,
            actor=user.remote_id,
            object=self.to_activity()
        )


class OrderedCollectionPageMixin(ActivitypubMixin):
    ''' just the paginator utilities, so you don't HAVE to
        override ActivitypubMixin's to_activity (ie, for outbox '''
    @property
    def collection_remote_id(self):
        ''' this can be overriden if there's a special remote id, ie outbox '''
        return self.remote_id

    def page(self, min_id=None, max_id=None):
        ''' helper function to create the pagination url '''
        params = {'page': 'true'}
        if min_id:
            params['min_id'] = min_id
        if max_id:
            params['max_id'] = max_id
        return '?%s' % urlencode(params)

    def next_page(self, items):
        ''' use the max id of the last item '''
        if not items.count():
            return ''
        return self.page(max_id=items[items.count() - 1].id)

    def prev_page(self, items):
        ''' use the min id of the first item '''
        if not items.count():
            return ''
        return self.page(min_id=items[0].id)

    def to_ordered_collection_page(self, queryset, remote_id, \
            id_only=False, min_id=None, max_id=None):
        ''' serialize and pagiante a queryset '''
        # TODO: weird place to define this
        limit = 20
        # filters for use in the django queryset min/max
        filters = {}
        if min_id is not None:
            filters['id__gt'] = min_id
        if max_id is not None:
            filters['id__lte'] = max_id
        page_id = self.page(min_id=min_id, max_id=max_id)

        items = queryset.filter(
            **filters
        ).all()[:limit]

        if id_only:
            page = [s.remote_id for s in items]
        else:
            page = [s.to_activity() for s in items]
        return activitypub.OrderedCollectionPage(
            id='%s%s' % (remote_id, page_id),
            partOf=remote_id,
            orderedItems=page,
            next='%s%s' % (remote_id, self.next_page(items)),
            prev='%s%s' % (remote_id, self.prev_page(items))
        ).serialize()

    def to_ordered_collection(self, queryset, \
            remote_id=None, page=False, **kwargs):
        ''' an ordered collection of whatevers '''
        remote_id = remote_id or self.remote_id
        if page:
            return self.to_ordered_collection_page(
                queryset, remote_id, **kwargs)
        name = ''
        if hasattr(self, 'name'):
            name = self.name

        size = queryset.count()
        return activitypub.OrderedCollection(
            id=remote_id,
            totalItems=size,
            name=name,
            first='%s%s' % (remote_id, self.page()),
            last='%s%s' % (remote_id, self.page(min_id=0))
        ).serialize()


class OrderedCollectionMixin(OrderedCollectionPageMixin):
    ''' extends activitypub models to work as ordered collections '''
    @property
    def collection_queryset(self):
        ''' usually an ordered collection model aggregates a different model '''
        raise NotImplementedError('Model must define collection_queryset')

    activity_serializer = activitypub.OrderedCollection

    def to_activity(self, **kwargs):
        ''' an ordered collection of the specified model queryset  '''
        return self.to_ordered_collection(self.collection_queryset, **kwargs)


@dataclass(frozen=True)
class ActivityMapping:
    ''' translate between an activitypub json field and a model field '''
    activity_key: str
    model_key: str
    activity_formatter: Callable = lambda x: x
    model_formatter: Callable = lambda x: x