baseapp-backend 0.0.1__tar.gz

baseapp-backend-0.0.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: baseapp-backend
+Version: 0.0.1
+Summary: BaseApp
+Home-page: https://github.com/silverlogic/baseapp-backend
+Author: The SilverLogic
+Author-email: dev@tsl.io
+License: BSD-3-Clause  # Example license
+Description: # BaseApp
+Platform: UNKNOWN
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

baseapp-backend-0.0.1/README.md

@@ -0,0 +1 @@
+# BaseApp

baseapp-backend-0.0.1/baseapp/activity_log/admin.py

@@ -0,0 +1,35 @@
+import swapper
+from django.contrib import admin
+
+ChatRoom = swapper.load_model("baseapp_chats", "ChatRoom")
+ChatRoomParticipant = swapper.load_model("baseapp_chats", "ChatRoomParticipant")
+Message = swapper.load_model("baseapp_chats", "Message")
+
+
+class ChatRoomParticipantInline(admin.TabularInline):
+    model = ChatRoomParticipant
+    extra = 0
+
+
+@admin.register(ChatRoomParticipant)
+class ChatRoomParticipantAdmin(admin.ModelAdmin):
+    list_display = ("profile", "room", "role")
+    list_filter = ["created", "role"]
+    search_fields = ["profile", "room"]
+
+
+@admin.register(Message)
+class MessageAdmin(admin.ModelAdmin):
+    list_display = ("profile", "verb", "action_object", "room", "timesince")
+    list_filter = ["verb"]
+    search_fields = ["content", "profile", "action_object", "room"]
+
+
+@admin.register(ChatRoom)
+class ChatRoomAdmin(admin.ModelAdmin):
+    list_display = ("room",)
+    search_fields = ["room"]
+    inlines = [ChatRoomParticipantInline]
+
+    def room(self, obj):
+        return obj.__str__()

baseapp-backend-0.0.1/baseapp/activity_log/apps.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+
+class ChatsConfig(AppConfig):
+    default = True
+    name = "baseapp_chats"
+    verbose_name = "BaseApp Chats"
+    default_auto_field = "django.db.models.BigAutoField"

baseapp-backend-0.0.1/baseapp/activity_log/base.py

@@ -0,0 +1,218 @@
+import swapper
+from baseapp_core.graphql.models import RelayModel
+from baseapp_core.models import random_name_in
+from django.conf import settings
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.utils import timezone
+from django.utils.timesince import timesince as djtimesince
+from django.utils.translation import gettext_lazy as _
+from model_utils.models import TimeStampedModel
+
+
+class AbstractBaseChatRoom(TimeStampedModel, RelayModel):
+    title = models.CharField(max_length=255, blank=True, null=True)
+    image = models.ImageField(
+        _("image"), upload_to=random_name_in("chat_room_images"), blank=True, null=True
+    )
+
+    created_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL, related_name="created_rooms", on_delete=models.CASCADE
+    )
+    last_message = models.ForeignKey(
+        swapper.get_model_name("baseapp_chats", "Message"),
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    last_message_time = models.DateTimeField(null=True, blank=True, default=timezone.now)
+    participants_count = models.IntegerField(default=0)
+    messages_count = models.IntegerField(default=0)
+
+    class Meta:
+        abstract = True
+        ordering = ["-last_message_time", "-created"]
+
+    def __str__(self):
+        return str(self.pk)
+
+    @classmethod
+    def get_graphql_object_type(cls):
+        from .graphql.object_types import ChatRoomObjectType
+
+        return ChatRoomObjectType
+
+
+class AbstractBaseMessage(TimeStampedModel, RelayModel):
+    class Verbs(models.IntegerChoices):
+        SENT_MESSAGE = 100, _("sent a message")
+
+    @property
+    def description(self):
+        return self.label
+
+    content = models.TextField(null=True, blank=True)
+
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, null=True, blank=True
+    )
+    profile = models.ForeignKey(
+        swapper.get_model_name("baseapp_profiles", "Profile"),
+        on_delete=models.CASCADE,
+        null=True,
+        blank=True,
+    )
+
+    verb = models.IntegerField(choices=Verbs.choices, default=Verbs.SENT_MESSAGE, db_index=True)
+
+    room = models.ForeignKey(
+        swapper.get_model_name("baseapp_chats", "ChatRoom"),
+        blank=True,
+        null=True,
+        related_name="messages",
+        on_delete=models.CASCADE,
+        db_index=True,
+    )
+
+    in_reply_to = models.ForeignKey(
+        swapper.get_model_name("baseapp_chats", "Message"),
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="replies",
+    )
+
+    action_object_content_type = models.ForeignKey(
+        ContentType,
+        blank=True,
+        null=True,
+        related_name="action_object",
+        on_delete=models.CASCADE,
+        db_index=True,
+    )
+    action_object_object_id = models.IntegerField(blank=True, null=True, db_index=True)
+    action_object = GenericForeignKey("action_object_content_type", "action_object_object_id")
+
+    extra_data = models.JSONField(blank=True, null=True)
+
+    class Meta:
+        abstract = True
+        ordering = ["-created"]
+
+    def __str__(self):
+        ctx = {
+            "actor": self.profile,
+            "verb": self.__class__.Verbs(self.verb).label,
+            "action_object": self.action_object,
+            "target": self.room,
+            "timesince": self.timesince(),
+        }
+        if self.room:
+            if self.action_object:
+                return (
+                    _("%(actor)s %(verb)s %(action_object)s on %(target)s %(timesince)s ago") % ctx
+                )
+            return _("%(actor)s %(verb)s on %(target)s %(timesince)s ago") % ctx
+        if self.action_object:
+            return _("%(actor)s %(verb)s %(action_object)s %(timesince)s ago") % ctx
+        return _("%(actor)s %(verb)s %(timesince)s ago") % ctx
+
+    def timesince(self, now=None):
+        """
+        Shortcut for the ``django.utils.timesince.timesince`` function of the
+        current timestamp.
+        """
+        return (
+            djtimesince(self.created, now).encode("utf8").replace(b"\xc2\xa0", b" ").decode("utf8")
+        )
+
+    @classmethod
+    def get_graphql_object_type(cls):
+        from .graphql.object_types import MessageObjectType
+
+        return MessageObjectType
+
+    def save(self, *args, **kwargs):
+        created = self._state.adding
+        super().save(*args, **kwargs)
+
+        if created:
+            from baseapp_chats.graphql.subscriptions import (
+                ChatRoomOnMessagesCountUpdate,
+            )
+
+            for participant in self.room.participants.all():
+                if participant.profile_id != self.profile_id:
+                    ChatRoomOnMessagesCountUpdate.send_updated_chat_count(
+                        profile=participant.profile, profile_id=participant.profile.relay_id
+                    )
+
+
+class AbstractChatRoomParticipant(TimeStampedModel, RelayModel):
+    class ChatRoomParticipantRoles(models.IntegerChoices):
+        MEMBER = 1, _("member")
+        ADMIM = 2, _("admin")
+
+        @property
+        def description(self):
+            return self.label
+
+    profile = models.ForeignKey(
+        swapper.get_model_name("baseapp_profiles", "Profile"),
+        on_delete=models.CASCADE,
+        null=True,
+        blank=True,
+    )
+    room = models.ForeignKey(
+        swapper.get_model_name("baseapp_chats", "ChatRoom"),
+        related_name="participants",
+        on_delete=models.CASCADE,
+    )
+    role = models.IntegerField(
+        choices=ChatRoomParticipantRoles.choices, default=ChatRoomParticipantRoles.MEMBER
+    )
+    accepted_at = models.DateTimeField(null=True, blank=True)
+
+    class Meta:
+        abstract = True
+        ordering = ["created"]
+
+    @classmethod
+    def get_graphql_object_type(cls):
+        from .graphql.object_types import ChatRoomParticipantObjectType
+
+        return ChatRoomParticipantObjectType
+
+
+class AbstractUnreadMessageCount(RelayModel):
+    room = models.ForeignKey(
+        swapper.get_model_name("baseapp_chats", "ChatRoom"),
+        on_delete=models.CASCADE,
+    )
+    profile = models.ForeignKey(
+        swapper.get_model_name("baseapp_profiles", "Profile"), on_delete=models.CASCADE
+    )
+    count = models.IntegerField(default=0)
+
+    class Meta:
+        abstract = True
+        ordering = ["id"]
+        unique_together = ["room_id", "profile_id"]
+
+
+class AbstractMessageStatus(RelayModel):
+    message = models.ForeignKey(
+        swapper.get_model_name("baseapp_chats", "Message"),
+        on_delete=models.CASCADE,
+        related_name="statuses",
+    )
+    profile = models.ForeignKey(
+        swapper.get_model_name("baseapp_profiles", "Profile"), on_delete=models.CASCADE
+    )
+    is_read = models.BooleanField(default=False)
+    read_at = models.DateTimeField(null=True, blank=True)
+
+    class Meta:
+        abstract = True
+        unique_together = ["message_id", "profile_id"]

baseapp-backend-0.0.1/baseapp/activity_log/graphql/filters.py

@@ -0,0 +1,26 @@
+import django_filters
+import swapper
+from baseapp_core.graphql import get_pk_from_relay_id
+from django.db.models import Q
+
+ChatRoom = swapper.load_model("baseapp_chats", "ChatRoom")
+
+
+class ChatRoomFilter(django_filters.FilterSet):
+    q = django_filters.CharFilter(method="filter_q")
+    profile_id = django_filters.CharFilter(method="filter_profile_id")
+
+    order_by = django_filters.OrderingFilter(fields=(("created", "created"),))
+
+    class Meta:
+        model = ChatRoom
+        fields = ["q", "order_by"]
+
+    def filter_q(self, queryset, name, value):
+        return queryset.filter(
+            Q(title__icontains=value) | Q(participants__profile__name__icontains=value)
+        )
+
+    def filter_profile_id(self, queryset, name, value):
+        pk = get_pk_from_relay_id(value)
+        return queryset.filter(participants__profile_id=pk)

baseapp-backend-0.0.1/baseapp/activity_log/graphql/interfaces.py

@@ -0,0 +1,46 @@
+import graphene
+import swapper
+from baseapp_core.graphql import get_object_type_for_model
+from django.db.models import Sum
+from graphene import relay
+from graphene_django.filter import DjangoFilterConnectionField
+
+ChatRoom = swapper.load_model("baseapp_chats", "ChatRoom")
+UnreadMessageCount = swapper.load_model("baseapp_chats", "UnreadMessageCount")
+Block = swapper.load_model("baseapp_blocks", "Block")
+
+
+class ActivityLogInterface(relay.Node):
+    activity_logs = DjangoFilterConnectionField(ActivityEventObjectType)
+
+    def resolve_chat_rooms(self, info, **kwargs):
+        if not info.context.user.has_perm("baseapp_chats.list_chatrooms", self):
+            return ChatRoom.objects.none()
+
+        qs = ChatRoom.objects.filter(
+            participants__profile_id=self.pk,
+        ).order_by("-last_message_time", "-created")
+
+        # Exclude rooms with any blocked participant
+        blocking_profile_ids = Block.objects.filter(actor_id=self.pk).values_list(
+            "target_id", flat=True
+        )
+        qs = qs.exclude(participants__profile_id__in=blocking_profile_ids)
+
+        # Exclude rooms with any participant that blocks the profile (self)
+        blocker_profile_ids = Block.objects.filter(target_id=self.pk).values_list(
+            "actor_id", flat=True
+        )
+        qs = qs.exclude(participants__profile_id__in=blocker_profile_ids)
+
+        return qs
+
+    def resolve_unread_messages_count(self, info, **kwargs):
+        if not info.context.user.has_perm("baseapp_chats.list_chatrooms", self):
+            return None
+
+        aggregate_result = UnreadMessageCount.objects.filter(
+            profile_id=self.pk,
+        ).aggregate(total_count=Sum("count"))
+
+        return aggregate_result["total_count"] or 0

baseapp-backend-0.0.1/baseapp/activity_log/graphql/mutations.py

@@ -0,0 +1,284 @@
+import graphene
+import swapper
+from baseapp_core.graphql import (
+    RelayMutation,
+    get_obj_from_relay_id,
+    get_pk_from_relay_id,
+    login_required,
+)
+from django.contrib.auth import get_user_model
+from django.db.models import Count, Q
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+from graphene_django.types import ErrorType
+
+from baseapp_chats.graphql.subscriptions import ChatRoomOnMessagesCountUpdate
+from baseapp_chats.utils import send_message, send_new_chat_message_notification
+
+ChatRoom = swapper.load_model("baseapp_chats", "ChatRoom")
+ChatRoomParticipant = swapper.load_model("baseapp_chats", "ChatRoomParticipant")
+Message = swapper.load_model("baseapp_chats", "Message")
+MessageStatus = swapper.load_model("baseapp_chats", "MessageStatus")
+Block = swapper.load_model("baseapp_blocks", "Block")
+User = get_user_model()
+Profile = swapper.load_model("baseapp_profiles", "Profile")
+
+
+ChatRoomObjectType = ChatRoom.get_graphql_object_type()
+ProfileObjectType = Profile.get_graphql_object_type()
+MessageObjectType = Message.get_graphql_object_type()
+
+
+class ChatRoomCreate(RelayMutation):
+    room = graphene.Field(ChatRoomObjectType._meta.connection.Edge)
+    profile = graphene.Field(ProfileObjectType)
+
+    class Input:
+        profile_id = graphene.ID(required=True)
+        participants = graphene.List(graphene.ID, required=True)
+
+    @classmethod
+    @login_required
+    def mutate_and_get_payload(cls, root, info, profile_id, participants, **input):
+        profile = get_obj_from_relay_id(info, profile_id)
+
+        if not info.context.user.has_perm("baseapp_profiles.use_profile", profile):
+            return ChatRoomCreate(
+                errors=[
+                    ErrorType(
+                        field="profile_id",
+                        messages=[_("You don't have permission to send a message as this profile")],
+                    )
+                ]
+            )
+
+        participants = [get_obj_from_relay_id(info, participant) for participant in participants]
+        participants = [participant for participant in participants if participant is not None]
+        participants_ids = [participant.pk for participant in participants]
+
+        # Check if participants are blocked
+        if Block.objects.filter(
+            Q(actor_id=profile.id, target_id__in=participants_ids)
+            | Q(actor_id__in=participants_ids, target_id=profile.id)
+        ).exists():
+            return ChatRoomCreate(
+                errors=[
+                    ErrorType(
+                        field="participants",
+                        messages=[_("You can't create a chatroom with those participants")],
+                    )
+                ]
+            )
+
+        participants.append(profile)
+
+        if len(participants) < 2:
+            return ChatRoomCreate(
+                errors=[
+                    ErrorType(
+                        field="participants",
+                        messages=[_("You need add at least one participant")],
+                    )
+                ]
+            )
+
+        if not info.context.user.has_perm(
+            "baseapp_chats.add_chatroom", {"profile": profile, "participants": participants}
+        ):
+            return ChatRoomCreate(
+                errors=[
+                    ErrorType(
+                        field="participants",
+                        messages=[_("You don't have permission to create a room")],
+                    )
+                ]
+            )
+
+        query_set = ChatRoom.objects.annotate(count=Count("participants")).filter(
+            count=len(participants)
+        )
+        for participant in participants:
+            query_set = query_set.filter(
+                participants__profile_id=participant.id,
+            )
+        existent_room = query_set.first()
+
+        if existent_room:
+            return ChatRoomCreate(
+                profile=profile,
+                room=ChatRoomObjectType._meta.connection.Edge(
+                    node=existent_room,
+                ),
+            )
+
+        room = ChatRoom.objects.create(
+            created_by=info.context.user, last_message_time=timezone.now()
+        )
+        for participant in participants:
+            ChatRoomParticipant.objects.create(profile=participant, room=room)
+
+        return ChatRoomCreate(
+            profile=profile,
+            room=ChatRoomObjectType._meta.connection.Edge(
+                node=room,
+            ),
+        )
+
+
+class ChatRoomSendMessage(RelayMutation):
+    message = graphene.Field(MessageObjectType._meta.connection.Edge)
+
+    class Input:
+        room_id = graphene.ID(required=True)
+        profile_id = graphene.ID(required=True)
+        content = graphene.String(required=True)
+        in_reply_to_id = graphene.ID(required=False)
+
+    @classmethod
+    @login_required
+    def mutate_and_get_payload(
+        cls, root, info, room_id, content, profile_id, in_reply_to_id=None, **input
+    ):
+        room = get_obj_from_relay_id(info, room_id)
+        profile = get_obj_from_relay_id(info, profile_id)
+
+        in_reply_to = None
+        if in_reply_to_id:
+            in_reply_to_pk = get_pk_from_relay_id(in_reply_to_id)
+            in_reply_to = Message.objects.filter(
+                pk=in_reply_to_pk,
+                room=room,
+            ).first()
+
+        if not info.context.user.has_perm("baseapp_profiles.use_profile", profile):
+            return ChatRoomSendMessage(
+                errors=[
+                    ErrorType(
+                        field="profile_id",
+                        messages=[_("You don't have permission to send a message as this profile")],
+                    )
+                ]
+            )
+
+        if not room or not info.context.user.has_perm(
+            "baseapp_chats.add_message", {"profile": profile, "room": room}
+        ):
+            return ChatRoomSendMessage(
+                errors=[
+                    ErrorType(
+                        field="room_id",
+                        messages=[_("You don't have permission to send a message in this room")],
+                    )
+                ]
+            )
+
+        if len(content) < 1:
+            return ChatRoomSendMessage(
+                errors=[
+                    ErrorType(
+                        field="content",
+                        messages=[_("You need to write something")],
+                    )
+                ]
+            )
+
+        if len(content) > 1000:
+            return ChatRoomSendMessage(
+                errors=[
+                    ErrorType(
+                        field="content",
+                        messages=[_("You can't write more than 1000 characters")],
+                    )
+                ]
+            )
+
+        message = send_message(
+            profile=profile,
+            user=info.context.user,
+            content=content,
+            room=room,
+            verb=Message.Verbs.SENT_MESSAGE,
+            room_id=room_id,
+            in_reply_to=in_reply_to,
+        )
+
+        send_new_chat_message_notification(room, message, info)
+
+        return ChatRoomSendMessage(
+            message=MessageObjectType._meta.connection.Edge(
+                node=message,
+            )
+        )
+
+
+class ChatRoomReadMessages(RelayMutation):
+    room = graphene.Field(ChatRoomObjectType)
+    profile = graphene.Field(ProfileObjectType)
+    messages = graphene.List(MessageObjectType)
+
+    class Input:
+        room_id = graphene.ID(required=True)
+        profile_id = graphene.ID(required=True)
+        message_ids = graphene.List(graphene.ID, required=False)
+
+    @classmethod
+    @login_required
+    def mutate_and_get_payload(cls, root, info, room_id, profile_id, message_ids=None, **input):
+        room = get_obj_from_relay_id(info, room_id)
+        profile = get_obj_from_relay_id(info, profile_id)
+
+        if not info.context.user.has_perm("baseapp_profiles.use_profile", profile):
+            return ChatRoomReadMessages(
+                errors=[
+                    ErrorType(
+                        field="profile_id",
+                        messages=[_("You don't have permission to act as this profile")],
+                    )
+                ]
+            )
+
+        if not ChatRoomParticipant.objects.filter(
+            profile_id=profile.pk,
+            room=room,
+        ).exists():
+            return ChatRoomReadMessages(
+                errors=[
+                    ErrorType(
+                        field="participant",
+                        messages=[_("Participant is not part of the room.")],
+                    )
+                ]
+            )
+
+        messages_status_qs = MessageStatus.objects.filter(
+            profile_id=profile.pk,
+            is_read=False,
+        )
+
+        if message_ids:
+            message_ids = [get_pk_from_relay_id(message_id) for message_id in message_ids]
+            messages_status_qs = messages_status_qs.filter(
+                message_id__in=message_ids,
+            )
+        else:
+            messages_status_qs = messages_status_qs.filter(
+                message__room_id=room.pk,
+            )
+
+        messages = Message.objects.filter(
+            pk__in=messages_status_qs.values_list("message_id", flat=True)
+        )
+
+        messages_status_qs.update(is_read=True, read_at=timezone.now())
+
+        ChatRoomOnMessagesCountUpdate.send_updated_chat_count(
+            profile=profile, profile_id=profile.relay_id
+        )
+
+        return ChatRoomReadMessages(room=room, profile=profile, messages=messages)
+
+
+class ChatsMutations(object):
+    chat_room_create = ChatRoomCreate.Field()
+    chat_room_send_message = ChatRoomSendMessage.Field()
+    chat_room_read_messages = ChatRoomReadMessages.Field()