etienne apprend à coder pitié

chat/models.py

@@ -1,40 +1,41 @@
-from django.db import models
-from django.db.models import IntegerField
+from django.db.models import Model, IntegerField, ForeignKey, CharField, CASCADE
+from django.db.models.signals import post_delete
+from django.dispatch import receiver
 from django.contrib.auth.models import User
-from django.contrib import admin
 
-# Create your models here.
-class ChatChannelModel(models.Model):
-    
-    def create(self, users_id: [int]):
+
+class ChatChannelModel(Model):
+    def create(self, members: [User]):
         self.save()
-        for user_id in users_id:
-            ChatMemberModel(channel_id = self.pk, member_id = user_id).save()
-        return self.pk
+        for member in members:
+            ChatMemberModel(channel=self, member=member).save()
+        return self
 
-    def get_members_id(self):
-        return [member_channel.member_id for member_channel in ChatMemberModel.objects.filter(channel_id = self.pk)]
+    def get_members(self):
+        return [member_channel.member for member_channel in ChatMemberModel.objects.filter(channel=self)]
 
-class ChatMemberModel(models.Model):
-    member_id = IntegerField(primary_key=False)
-    channel_id = IntegerField(primary_key=False)
 
-    def __str__(self):
-        return "member_id: " + str(self.member_id) + ", channel_id: " + str(self.channel_id)
+class ChatMemberModel(Model):
+    member = ForeignKey(User, on_delete=CASCADE)
+    channel = ForeignKey(ChatChannelModel, on_delete=CASCADE)
 
-class ChatMessageModel(models.Model):
-    channel_id = IntegerField(primary_key=False)
-    author_id = IntegerField(primary_key=False)
-    content = models.CharField(max_length=255)
+
+@receiver(post_delete, sender=ChatMemberModel)
+def delete_channel_when_member_deleted(sender, instance, **kwargs):
+    print(sender, instance)
+
+
+class ChatMessageModel(Model):
+    channel = ForeignKey(ChatChannelModel, on_delete=CASCADE)
+    author = ForeignKey(User, on_delete=CASCADE)
+    content = CharField(max_length=255)
     time = IntegerField(primary_key=False)
 
-    def __str__(self): 
-        return "author_id: " + str(self.author_id) + ", channel_id: " + str(self.channel_id) + ", content: " + self.content
 
-class AskModel(models.Model):
-	asker_id = IntegerField(primary_key=False)
-	asked_id = IntegerField(primary_key=False)
+class AskModel(Model):
+    asker_id = IntegerField(primary_key=False)
+    asked_id = IntegerField(primary_key=False)
 
-	# return if the asker ask the asked to play a game 
-	def is_asked(self, asker_id, asked_id):
-		return AskModel.objects.get(asker_id=asker_id, asked_id=asked_id) != None
+    # return if the asker ask the asked to play a game
+    def is_asked(self, asker_id, asked_id):
+        return AskModel.objects.get(asker_id=asker_id, asked_id=asked_id) is not None

chat/serializers/chat.py

@@ -1,17 +1,19 @@
 from rest_framework import serializers
 
 from django.utils.translation import gettext as _
+from django.contrib.auth.models import User
 
-from profiles.models import ProfileModel
 from ..models import ChatChannelModel, ChatMessageModel
 
+
 class ChatChannelSerializer(serializers.ModelSerializer):
 
-    members_id = serializers.ListField(child=serializers.IntegerField())
+    members_id = serializers.ListField(child=serializers.IntegerField(), required=True, write_only=True)
+    messages = serializers.SerializerMethodField()
 
     class Meta:
         model = ChatChannelModel
-        fields = ["members_id", "pk"]
+        fields = ["members_id", "id", 'messages']
 
     def validate_members_id(self, value):
         members_id: [int] = value
@@ -19,14 +21,20 @@ class ChatChannelSerializer(serializers.ModelSerializer):
             raise serializers.ValidationError(_('There is not enough members to create the channel.'))
         if len(set(members_id)) != len(members_id):
             raise serializers.ValidationError(_('Duplicate in members list.'))
+        if self.context.get('user').pk not in members_id:
+            raise serializers.ValidationError(_('You are trying to create a group chat without you.'))
         for member_id in members_id:
-            if not ProfileModel.objects.filter(pk=member_id).exists():
+            if not User.objects.filter(pk=member_id).exists():
                 raise serializers.ValidationError(_(f"The profile {member_id} doesn't exist."))
         return members_id
 
+    def get_messages(self, obj: ChatChannelModel):
+        messages = ChatMessageModel.objects.filter(channel=obj).order_by('time')
+        return ChatMessageSerializer(messages, many=True).data
 
-class ChatMessageSerializer(serializers.Serializer):
+
+class ChatMessageSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = ChatMessageModel
-        fields = ["channel_id", "author_id", "content", "time"]
+        fields = ["channel", "author", "content", "time"]

chat/urls.py

@@ -1,6 +1,4 @@
 from django.urls import path
-from django.conf import settings
-from django.conf.urls.static import static
 
 from .views import chat
 from .views import ask

chat/views/chat.py

@@ -1,48 +1,31 @@
 from rest_framework.views import APIView
 from rest_framework.response import Response
-from rest_framework import permissions, status
+from rest_framework import permissions
 from rest_framework.authentication import SessionAuthentication
 
-from django.http import HttpRequest
-from django.contrib.auth import login
-from django.db.models import QuerySet
-from django.core import serializers
+from django.contrib.auth.models import User
 
+from ..models import ChatChannelModel, ChatMemberModel
+from ..serializers import ChatChannelSerializer
 
-from ..models import ChatChannelModel, ChatMemberModel, ChatMessageModel
-from ..serializers.chat import ChatChannelSerializer, ChatMessageSerializer
 
 class ChannelView(APIView):
-    
-    queryset = ChatChannelModel.objects
+
     serializer_class = ChatChannelSerializer
     permission_classes = (permissions.IsAuthenticated,)
-    authentication_classes = (SessionAuthentication,)    
+    authentication_classes = (SessionAuthentication,)
 
     def post(self, request):
-
-        serializer = self.serializer_class(data = request.data)
-        
+        serializer = self.serializer_class(data=request.data, context={'user': request.user})
         serializer.is_valid(raise_exception=True)
 
-        data: dict = serializer.validated_data
+        members_id = serializer.validated_data.get('members_id')
+        member_list = [User.objects.get(pk=member_id) for member_id in members_id]
 
-        members_id = data.get("members_id")
-        if members_id == None:
-            return Response({"detail": "members_id is None."}, status = status.HTTP_400_BAD_REQUEST)
-
-        if self.request.user.pk not in members_id:
-            return Response({"detail": "You are trying to create a chat group without you."}, status = status.HTTP_400_BAD_REQUEST)
-
-        for member_channel in ChatMemberModel.objects.filter(member_id = members_id[0]):
-            channel_id: int = member_channel.channel_id
-            if not ChatChannelModel.objects.filter(pk = channel_id).exists():
-                continue
-            channel: ChatChannelModel = ChatChannelModel.objects.get(pk = channel_id)
-            if set(channel.get_members_id()) == set(members_id):
-                messages = ChatMessageModel.objects.filter(channel_id = channel_id).order_by("time")
-                messages = serializers.serialize("json", messages)
-                return Response({'channel_id': channel_id, 'messages': messages}, status=status.HTTP_200_OK)                
-
-        new_channel_id = ChatChannelModel().create(members_id)
-        return Response({'channel_id': new_channel_id}, status=status.HTTP_201_CREATED)
+        for member_channel in ChatMemberModel.objects.filter(member=member_list[0]):
+            channel: ChatChannelModel = member_channel.channel
+            if set(channel.get_members()) == set(member_list):
+                break
+        else:
+            channel = ChatChannelModel().create(member_list)
+        return Response(self.serializer_class(channel).data)