drf-directmessages 0.0.1__tar.gz

drf_directmessages-0.0.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: drf-directmessages
+Version: 0.0.1
+Summary: An API allowing users to directly message each other.
+Author: Garreth Cain
+Author-email: garrethccain@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: django (>=4.2.1,<5.0.0)
+Requires-Dist: djangorestframework (>=3.14.0,<4.0.0)
+Description-Content-Type: text/markdown
+
+# DirectMessages
+
+A small, lightweight and easy to use Rest endpoint to add messaging between
+your users.
+

drf_directmessages-0.0.1/README.md

@@ -0,0 +1,4 @@
+# DirectMessages
+
+A small, lightweight and easy to use Rest endpoint to add messaging between
+your users.

drf_directmessages-0.0.1/directmessages/__init__.py

@@ -0,0 +1,11 @@
+__version__ = '0.9.7'
+
+try:
+    from django import VERSION as DJANGO_VERSION
+    if DJANGO_VERSION >= (1, 7):
+        default_app_config = 'directmessages.apps.DirectmessagesConfig'
+    else:
+        from directmessages.apps import populateInbox
+        populateInbox()
+except ImportError:
+    pass

drf_directmessages-0.0.1/directmessages/admin.py

@@ -0,0 +1,8 @@
+from .models import Message
+from django.contrib import admin
+
+class MessageAdmin(admin.ModelAdmin):
+    model = Message
+    list_display = ('id', 'sender', 'content', )
+
+admin.site.register(Message, MessageAdmin)

drf_directmessages-0.0.1/directmessages/apps.py

@@ -0,0 +1,14 @@
+from django.apps import AppConfig
+
+Inbox = None
+
+
+class AppConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "directmessages"
+
+    def ready(self):
+        # For convenience
+        from .services import MessagingService
+        global Inbox
+        Inbox = MessagingService()

drf_directmessages-0.0.1/directmessages/migrations/0001_initial.py

@@ -0,0 +1,58 @@
+# Generated by Django 4.2.1 on 2023-05-13 08:24
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Message",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("content", models.TextField(verbose_name="Content")),
+                (
+                    "sent_at",
+                    models.DateTimeField(auto_now=True, verbose_name="sent at"),
+                ),
+                (
+                    "read_at",
+                    models.DateTimeField(blank=True, null=True, verbose_name="read at"),
+                ),
+                (
+                    "recipient",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="received_dm",
+                        to=settings.AUTH_USER_MODEL,
+                        verbose_name="Recipient",
+                    ),
+                ),
+                (
+                    "sender",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="sent_dm",
+                        to=settings.AUTH_USER_MODEL,
+                        verbose_name="Sender",
+                    ),
+                ),
+            ],
+        ),
+    ]

drf_directmessages-0.0.1/directmessages/models.py

@@ -0,0 +1,44 @@
+from django.db import models
+from django.utils import timezone
+from django.contrib.auth import get_user_model
+from django.core.exceptions import ValidationError
+
+
+# from django.contrib.auth.models import User
+
+User = get_user_model()
+
+
+class Message(models.Model):
+    """
+    A private directmessage
+    """
+    content = models.TextField('Content')
+    sender = models.ForeignKey(User,
+                               related_name='sent_dm',
+                               verbose_name="Sender",
+                               on_delete=models.CASCADE)
+    recipient = models.ForeignKey(User,
+                                  related_name='received_dm',
+                                  verbose_name="Recipient",
+                                  on_delete=models.CASCADE)
+    sent_at = models.DateTimeField("sent at", auto_now=True)
+    read_at = models.DateTimeField("read at", null=True, blank=True)
+
+    @property
+    def unread(self):
+        """
+        returns whether the message was read or not
+        """
+        return self.read_at is None
+
+    def __str__(self):
+        return f"{self.id}/{self.sender}/{self.recipient}/{self.content}"
+
+    def save(self, **kwargs):
+        if self.sender == self.recipient:
+            raise ValidationError("You can't send messages to yourself")
+
+        if not self.id:
+            self.sent_at = timezone.now()
+        super(Message, self).save(**kwargs)

drf_directmessages-0.0.1/directmessages/serializers.py

@@ -0,0 +1,85 @@
+from django.contrib.auth import get_user_model
+
+from rest_framework import serializers
+
+from .models import Message
+
+
+User = get_user_model()
+
+
+class UnreadMessageSerializer(serializers.ModelSerializer):
+    count = serializers.SerializerMethodField()
+
+    def get_count(self, obj):
+        breakpoint()
+        return Message.objects.filter(read_at=None, recipient=obj).count()
+
+    class Meta:
+        model = User
+        fields = (
+            "id",
+            "count",
+        )
+
+
+class ConversationSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = User
+        fields = (
+            "id",
+            "email",
+            "first_name",
+            "last_name",
+            "is_active",
+            "date_joined",
+        )
+
+
+class MessageSerializer(serializers.ModelSerializer):
+    direction = serializers.SerializerMethodField()
+
+    def get_direction(self, obj):
+        request = self.context.get("request")
+        user_id = request.user if request else None
+        if type(obj) != Message:
+            return ""
+        return (
+            "in" if user_id == obj.recipient
+            else
+            "out"
+        )
+
+    class Meta:
+        model = Message
+        fields = (
+            "id",
+            "sender",
+            "recipient",
+            "direction",
+            "sent_at",
+            "read_at",
+            "content",
+        )
+        read_only_fields = (
+            "sender",
+            "recipient",
+            "sent_at",
+            "read_at",
+        )
+
+
+class MessageSendSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Message
+        fields = (
+            "id",
+            "content",
+        )
+        read_only_fields = (
+            " sender",
+            "sent_at",
+            "read_at",
+        )

drf_directmessages-0.0.1/directmessages/services.py

@@ -0,0 +1,152 @@
+from __future__ import unicode_literals
+
+from .models import Message
+from .signals import message_read, message_sent
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+from django.db.models import Q
+
+
+class MessagingService(object):
+    """
+    A object to manage all messages and conversations
+    """
+
+    # Message creation
+
+    def send_message(self, sender, recipient, message):
+        """
+        Send a new message
+        :param sender: user
+        :param recipient: user
+        :param message: String
+        :return: Message and status code
+        """
+
+        if sender == recipient:
+            raise ValidationError("You can't send messages to yourself.")
+
+        message = Message(
+            sender=sender,
+            recipient=recipient,
+            content=str(message))
+        message.save()
+
+        message_sent.send(sender=message,
+                          from_user=message.sender,
+                          to=message.recipient)
+
+        # The second value acts as a status value
+        return message, 200
+
+    # Message reading
+    def get_unread_messages(self, user):
+        """
+        List of unread messages for a specific user
+        :param user: user
+        :return: messages
+        """
+        return Message.objects.all().filter(recipient=user,
+                                            read_at=None).distinct()
+
+    # Message reading
+    def get_unread_message_count(self, user):
+        """
+        Count of unread messages for a specific user
+        :param user: user
+        :return: messages
+        """
+        return Message.objects.all().filter(recipient=user,
+                                            read_at=None).count()
+
+    def read_message(self, message_id):
+        """
+        Read specific message
+        :param message_id: Integer
+        :return: Message Text
+        """
+        try:
+            message = Message.objects.get(id=message_id)
+            self.mark_as_read(message)
+            return message.content
+        except Message.DoesNotExist:
+            return ""
+
+    def read_message_formatted(self, message_id):
+        """
+        Read a message in the format <User>: <Message>
+        :param message_id: Id
+        :return: Formatted Message Text
+        """
+        try:
+            message = Message.objects.get(id=message_id)
+            self.mark_as_read(message)
+            return f"{message.sender.email}: {message.content}"
+        except Message.DoesNotExist:
+            return ""
+
+    ######
+    # Conversation management
+    ######
+    def get_conversations(self, user):
+        """
+        Lists all conversation-partners for a specific user
+        :param user: User
+        :return: Conversation list
+        """
+        all_conversations = Message.objects.all().filter(
+            Q(sender=user) | Q(recipient=user)
+        )
+
+        contacts = []
+        for conversation in all_conversations:
+            if conversation.sender != user:
+                contacts.append(conversation.sender)
+            elif conversation.recipient != user:
+                contacts.append(conversation.recipient)
+
+        # To abolish duplicates
+        return list(set(contacts))
+
+    def get_conversation(self, user1, user2, limit=None,
+                         reversed=False, mark_read=False):
+        """
+        List of messages between two users
+        :param user1: User
+        :param user2: User
+        :param limit: int
+        :param reversed: Boolean - Makes the newest message be at index 0
+        :return: messages
+        """
+        users = [user1, user2]
+
+        # Newest message first if it's reversed (index 0)
+        order = "-pk" if reversed else "pk"
+        conversation = Message.objects.all().filter(
+            sender__in=users,
+            recipient__in=users).order_by(order)
+
+        if limit:
+            # Limit number of messages to the x newest
+            conversation = conversation[:limit]
+
+        if mark_read:
+            for message in conversation:
+                # Just to be sure, everything is read
+                self.mark_as_read(message)
+
+        return conversation
+
+    # Helper methods
+    def mark_as_read(self, message):
+        """
+        Marks a message as read, if it hasn't been read before
+        :param message: Message
+        """
+
+        if message.read_at is None:
+            message.read_at = timezone.now()
+            message_read.send(sender=message,
+                              from_user=message.sender,
+                              to=message.recipient)
+            message.save()

drf_directmessages-0.0.1/directmessages/signals.py

@@ -0,0 +1,4 @@
+from django.dispatch import Signal
+
+message_sent = Signal()  # Signal(providing_args=['from_user', 'to'])
+message_read = Signal()  # Signal(providing_args=['from_user', 'to'])

drf_directmessages-0.0.1/directmessages/urls.py

@@ -0,0 +1,15 @@
+from django.urls import path
+from .views import (
+    ConversationListView,
+    MessageListView,
+    UnreadMessagesView,
+    MessageSendView
+)
+
+
+urlpatterns = [
+    path("unread/", view=UnreadMessagesView.as_view()),
+    path("conversations/", view=ConversationListView.as_view()),
+    path("conversations/<int:pk>", view=MessageListView.as_view()),
+    path("send/<int:pk>/", view=MessageSendView.as_view()),
+]

drf_directmessages-0.0.1/directmessages/views.py

@@ -0,0 +1,85 @@
+
+from django.core.exceptions import ValidationError
+from django.contrib.auth import get_user_model
+
+from rest_framework import (
+    generics,
+    status,
+    views)
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+
+from .apps import Inbox
+from .models import Message
+from .serializers import (
+    ConversationSerializer,
+    MessageSendSerializer,
+    MessageSerializer,
+    UnreadMessageSerializer)
+from .services import MessagingService
+
+
+User = get_user_model()
+
+
+class MessageViewBase:
+    permission_classes = [IsAuthenticated,]
+
+    def get_user(self):
+        return self.request.user
+
+    def get_recipient(self):
+        return User.objects.get(id=self.kwargs['pk'])
+
+
+class UnreadMessagesView(MessageViewBase, views.APIView):
+    serializer_class = UnreadMessageSerializer
+
+    def get(self, request):
+        user = self.get_user()
+        serializer = UnreadMessageSerializer(user)
+        return Response(data=serializer.data)
+
+
+class ConversationListView(MessageViewBase, generics.ListAPIView):
+    serializer_class = ConversationSerializer
+
+    def get_queryset(self):
+        return Inbox.get_conversations(self.get_user())
+
+
+class MessageListView(MessageViewBase, generics.ListCreateAPIView):
+    serializer_class = MessageSerializer
+
+    def get_queryset(self):
+        user1 = self.get_user()
+        user2 = self.kwargs['pk']
+        return Inbox.get_conversation(
+                user1=user1, user2=user2, mark_read=True).order_by('-sent_at')
+
+    def create(self, request, *args, **kwargs):
+        sender = self.get_user()
+        recipient = self.get_recipient()
+        content = request.data.get('content')
+        _ = Message.objects.create(
+                sender=sender, recipient=recipient, content=content)
+        return Response(MessageSerializer(
+                self.get_queryset(),
+                many=True).data, status=status.HTTP_201_CREATED)
+
+
+class MessageSendView(MessageViewBase, generics.CreateAPIView):
+    serializer_class = MessageSendSerializer
+
+    def create(self, request, *args, **kwargs):
+        sender = self.get_user()
+        recipient = self.get_recipient()
+        content = request.data.get('content')
+
+        ms = MessagingService()
+        try:
+            ms.send_message(
+                    sender=sender, recipient=recipient, message=content)
+        except ValidationError as e:
+            return Response(e, status=status.HTTP_400_BAD_REQUEST)
+        return Response(status=status.HTTP_201_CREATED)

drf_directmessages-0.0.1/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "drf-directmessages"
+version = "0.0.1"
+description = "An API allowing users to directly message each other."
+authors = ["Garreth Cain <garrethccain@gmail.com>"]
+readme = "README.md"
+packages = [{include = "directmessages"}]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+django = "^4.2.1"
+djangorestframework = "^3.14.0"
+
+
+[tool.poetry.group.test.dependencies]
+pytest = "^7.3.1"
+requests-mock = "^1.10.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"