Django Activity Stream with Django REST Framework

class ActionSerializer(Serializer):
    """
    DRF serializer for :class:`~activity.models.Action`.
    """
    actor = fields.ActivityGenericRelatedField(read_only=True)
    action_object = fields.ActivityGenericRelatedField(read_only=True)
    target = fields.ActivityGenericRelatedField(read_only=True)

    class Meta(Serializer.Meta):
        model = Action
        fields = ('id', 'actor', 'verb', 'action_object', 'target', 'public', 'description', 'timestamp')

# Registry of GFK serializers used in activity stream.
GFK_MODEL_SERIALIZER_MAPPING = {
    User: UserActionSerializer,
    Bot: BotActionSerializer,
    Team: TeamActionSerializer,
    Commit: CommitActionSerializer,
    Star: FunctionActionSerializer,
    Push: PushActionSerializer,
    PullRequest: PullRequestActionSerializer,
    Organization: OrganizationActionSerializer,
    Repository: RepositoryActionSerializer
}

class ActivityGenericRelatedField(serializers.Field):
    """
    DRF Serializer field that serializers GenericForeignKey fields on the :class:`~activity.models.Action`
    of known model types to their respective ActionSerializer implementation.
    """

    def to_representation(self, value):
        serializer_cls = GFK_MODEL_SERIALIZER_MAPPING.get(type(value), None)
        return serializer_cls(value, context=self.context).data if serializer_cls else str(value)

class OrganizationActionSerializer(ModelSerializer):
    """
    DRF model serializer for :class:`~organizations.models.Organization` when referenced
    from an action.
    """

    class Meta:
        fields = ('id', 'url', 'model_type', 'name', 'slug')
        read_only_fields = ('id', 'url', 'model_type', 'name', 'slug')

class ActorModel(Model):
    """
    Mixin to add activity related functionality to activity 'actor' model types.
    """

    def activity_stream(self, limit=25):
        """
        Returns queryset that yields back :class:`~activity.models.Action` instances
        where the current model instance was any part (actor, target, or action_object) of the action.
        """
        return Action.objects.any(self, _limit=limit)

    class Meta:
        abstract = True

class ActivityViewSetMixin:
    def activity(self, request, *args, **kwargs):
        """
        Get activity stream for the current object.
        """
        obj = self.get_object()
        queryset = obj.activity_stream()
        return responses.serialized_list_response(self, queryset)

user_activity = viewsets.UserView.as_view({'get': 'activity'})

urlpatterns = [
    path('users/<uuid:user_pk>/', include([
        path('activity', user_activity, name='user-activity')
    ]))
]

class Flags:
    """
    Contains common used follow flags.
    """
    Following = 'following'



class ActorModel(Model):
    """
    Mixin to add activity related functionality to activity 'actor' model types.
    """

    def activity_stream(self, limit=25):
        """
        Returns queryset that yields back :class:`~activity.models.Action` instances
        where the current model instance was any part (actor, target, or action_object) of the action.
        """
        return Action.objects.any(self, _limit=limit)

    def followers(self, limit=25):
        """
        Returns queryset that yields back :class:`~activity.models.Follow` instances
        that contain references to users following this instance.
        """
        return Follow.objects.followers_qs(self, flag=actions.Flags.Following)[:limit]

    class Meta:
        abstract = True


class UserModel(ActorModel):
    """
    Mixin to add activity related functionality to activity user model types.
    """

    def user_stream(self, limit=25):
        """
        Returns queryset that yields back :class:`~activity.models.Action` instances
        related to actors this user is following.
        """
        return Action.objects.user(self, follow_flag=actions.Flags.Following, _limit=limit)

    def following(self, limit=25):
        """
        Returns queryset that yields back :class:`~activity.models.Follow` instances
        that contain references to users the current user is following.
        """
        return Follow.objects.following_qs(self, flag=actions.Flags.Following)[:limit]

    class Meta:
        abstract = True

class FeedViewSetMixin:
    """
    Mixin that adds a 'feed' action to the viewset.

    This requires that the model being served by the viewset has the
    :class:`~activity.models.UserMixin`.
    """
    feed_serializer_class = serializers.ActionListSerializer

    def feed(self, request, *args, **kwargs):
        """
        Get user stream for the current object.
        """
        obj = request.user
        queryset = obj.user_stream()
        return responses.serialized_list_response(self, queryset)


class FollowViewSetMixin:
    """
    Mixin that adds 'follow' action to ViewSet.
    """

    def follow(self, request, *args, **kwargs):
        """
        Configure authenticated user to follow object stream.
        """
        user, obj = request.user, self.get_object()

        with transaction.atomic():
            signals.pre_follow.send(sender=obj.__class__, instance=obj, user=user)
            actions.follow(user, obj)
            signals.post_follow.send(sender=obj.__class__, instance=obj, user=user)

        return responses.NoContent()


class UnfollowViewSetMixin:
    """
    Mixin that adds 'unfollow' action to the ViewSet.
    """

    def unfollow(self, request, *args, **kwargs):
        """
        Configure authenticated user to unfollow object stream.
        """
        user, obj = request.user, self.get_object()

        with transaction.atomic():
            signals.pre_unfollow.send(sender=obj.__class__, instance=obj, user=user)
            actions.unfollow(user, obj)
            signals.post_unfollow.send(sender=obj.__class__, instance=obj, user=user)

        return responses.NoContent()


class FollowersViewSetMixin:
    """
    Mixin that adds 'followers' action to the ViewSet.
    """
    followers_serializer_class = serializers.FollowersSerializer

    def followers(self, request, *args, **kwargs):
        """
        Get list of users that are following the current actor.
        """
        obj = self.get_object()
        queryset = obj.followers()
        return responses.serialized_list_response(self, queryset)


class FollowingViewSetMixin:
    """
    Mixin that adds 'following' action to the ViewSet.
    """
    following_serializer_class = serializers.FollowingSerializer

    def following(self, request, *args, **kwargs):
        """
        Get list of actors the current user is following.
        """
        obj = request.user
        queryset = obj.following()
        return responses.serialized_list_response(self, queryset)

user_activity = viewsets.UserViewSet.as_view({'get': 'activity'})
user_followers = viewsets.UserViewSet.as_view({'get': 'followers'})
user_follow = viewsets.UserViewSet.as_view({'post': 'follow'})
user_unfollow = viewsets.UserViewSet.as_view({'delete': 'unfollow'})

urlpatterns = [
    path('users/<uuid:user_pk>/', include([
        path('activity', user_activity, name='user-activity'),
        path('followers', user_followers, name='user-followers'),
        path('follow', user_follow, name='user-follow'),
        path('unfollow', user_unfollow, name='user-unfollow')
    ]))
]