Changes

backend/api/serializers.py

@@ -32,7 +32,14 @@ def generate_username(email):
     # Return the username with the unique number appended
     return username
 
+class UserSerializerN(serializers.ModelSerializer):
 
+
+    class Meta:
+        model = User
+        fields =["username"]
+
+
 class UserSerializer(serializers.ModelSerializer):
     profile_picture = serializers.ImageField(
         source="client.profile_picture", read_only=True, required=False
@@ -301,6 +308,8 @@ class Meta:
 
 class PostSerializer(serializers.ModelSerializer):
     first_name = serializers.CharField(source="Freelancer.user.first_name", read_only=True, required=False)
+    username = serializers.CharField(source="Freelancer.user.username", read_only=True, required=False)
+
     user_id=serializers.CharField(source="Freelancer.user.id", read_only=True, required=False)
     categorydata = serializers.CharField(
         source="category.category_name", read_only=True, required=False
@@ -318,6 +327,7 @@ class PostSerializer(serializers.ModelSerializer):
     class Meta:
         model = CreatePost
         fields = [
+            "username",
             "first_name",
             "bio",
            "profile_picture",

backend/api/urls.py

@@ -9,6 +9,7 @@
     path("logout/", views.LogOut, name="logout"),
     path("cpost/", views.PostView.as_view(), name="create_post"),
     path("login/", views.LoginView.as_view(), name="login"),
+     path("chatuser/", views.chatUser.as_view(), name="login"),
     path("block/", views.BlockUnblockView.as_view(), name="block"),
     path("skills/",views.SkillsView.as_view(),name='skills'),
     path("cprofileData/", views.ClientDetailsView.as_view(), name="client_update_view"),

backend/api/views.py

@@ -1,6 +1,7 @@
 from django.shortcuts import render
 from rest_framework.views import APIView
 from rest_framework import exceptions
+import json
 from rest_framework.permissions import AllowAny, IsAuthenticated
 from rest_framework_simplejwt.serializers import TokenObtainPairSerializer
 from rest_framework_simplejwt.views import TokenObtainPairView
@@ -25,6 +26,8 @@
 from rest_framework.parsers import MultiPartParser, FormParser
 from rest_framework import status
 from rest_framework.response import Response
+from chat.models import Message,Conversation
+from chat.serializers import MessageSerializer,UserMessageSerializer
 from .serializers import (
     ExpSerializer,
     UserSerializer,
@@ -545,7 +548,24 @@ def post(self,request):
         return Response(serializer.data,status=status.HTTP_200_OK) 
 # logout
 
-
+class chatUser(APIView):
+    def get(self,request):
+           print(request.user)
+           users=[]
+           messages=Message.objects.filter(to_user=request.user)
+           print(messages,"this is messages")
+           for message in messages:
+               print(users)
+               if message.from_user.username not in users:
+
+                    users.append(message.from_user.username)
+           print(users)
+
+
+           return Response({"username":users},status=status.HTTP_200_OK)
+        # except:
+        #     return Response(status=status.HTTP_400_BAD_REQUEST)
+
 @api_view(["POST"])
 def LogOut(request):
     print(request.user)

backend/chat/admin.py

@@ -1,3 +1,6 @@
 from django.contrib import admin
+from .models import Conversation, Message
 
-# Register your models here.
+
+admin.site.register(Conversation)
+admin.site.register(Message)

backend/chat/consumers.py

@@ -1,92 +1,157 @@
 import json
 from django.contrib.auth import get_user_model
 from asgiref.sync import async_to_sync
-from channels.generic.websocket import WebsocketConsumer
+from channels.generic.websocket import JsonWebsocketConsumer
+from .serializers import MessageSerializer
 from api.models import FreeLancer,Client
-from .models import Messages
+from .models import Message,Conversation
+import json
 User=get_user_model()
+class Encoder(json.JSONEncoder):
+    def default(self,obj):
+        return json.JSONEncoder(self,obj)
+def new_message_notification(self, event):
+    self.send_json(event)
+class ChatConsumer(JsonWebsocketConsumer):
+    """
+    This consumer is used to show user's online status,
+    and send notifications.
+    """
 
-class ChatConsumer(WebsocketConsumer):
-    def fetch_messages(self,data):
-        print("fetch")
-        messages=Messages.last_10_messages(self)
-        content={
-           'messages': self.messages_to_json(messages)
-        }
-        self.send_message(content)
-    def messages_to_json(self,messages):
-        result=[]
-        for message in messages:
-            result.append(self.message_to_json(message))
-        return result
-    def message_to_json(self,message):
-        return {
-            "client":message.client.user.first_name,
-            "freelancer":message.freelancer.user.first_name,
-            "content":message.content,
-            # "timestamp":message.timestamp
-        }
-
-    def new_messages(self,data):
-        print(data,"data in new messages")
-        id_of_client=data['user_id']
-        id_of_freelancer=data['freelancer_id']
-        client_user=User.objects.get(pk=id_of_client)
-        freelancer_user=User.objects.get(pk=id_of_freelancer)
-        client=Client.objects.get(user=client_user)
-        freelancer=FreeLancer.objects.get(user=freelancer_user)
-        message=Messages.objects.create(client=client,freelancer=freelancer,content=data['message'])
-        content={
-            "command":"new_message",
-            "message":self.message_to_json(message)
-        }
-        return self.send_chat_message(content)
+    def __init__(self, *args, **kwargs):
 
+        super().__init__(*args,**kwargs)
+
+        self.user=None
+        self.conversation_name=None
+        self.conversation=None
+    @classmethod
+    def encode_json(cls, content):
+        print(content)
+        return json.dumps(content, cls=Encoder)
 
-    commands={
-        'fetch_messages':fetch_messages,
-        'new_messages':new_messages
-    }
-
     def connect(self):
-        print("hello")
-        #obbaining room_name params from the url route(chat/routing.py)
-        self.room_name = self.scope["url_route"]["kwargs"]["room_name"]
-        self.room_group_name = "chat_%s" % self.room_name
-
-        # Join room group
+        self.user = self.scope['user']
+        if not self.user.is_authenticated:
+            return
+        self.accept()
+        print(self.scope['url_route'])
+        self.conversation_name = f"{self.scope['url_route']['kwargs']['conversation_name']}"
+        self.conversation, created = Conversation.objects.get_or_create(name=self.conversation_name)
         async_to_sync(self.channel_layer.group_add)(
-            self.room_group_name, self.channel_name
+        self.conversation_name,
+        self.channel_name,
+    ) 
+        messages = self.conversation.messages.all().order_by("-timestamp")[0:50]
+        self.send_json({
+    "type": "last_50_messages",
+    "messages": MessageSerializer(messages, many=True).data,
+})
+    def disconnect(self, code):
+        print("Disconnected!")
+        return super().disconnect(code)
+
+    def get_receiver(self):
+        usernames=self.conversation_name.split("__")
+        for username in usernames:
+            if username != self.user.username:
+                return User.objects.get(username=username)
+    def receive_json(self, content, **kwargs):
+        message_type=content["type"]
+        if message_type == "read_messages":
+            messages_to_me = self.conversation.messages.filter(to_user=self.user)
+            messages_to_me.update(read=True)
+            print(self.user.username)
+            # Update the unread message count
+            unread_count = Message.objects.filter(to_user=self.user, read=False).count()
+            async_to_sync(self.channel_layer.group_send)(
+                self.user.username + "__notifications",
+                {
+                    "type": "unread_count",
+                    "unread_count": unread_count,
+                },
+            )
+        if message_type == "chat_message":
+            message=Message.objects.create(from_user=self.user,to_user=self.get_receiver(),
+                                           content=content["message"],
+                                           conversation=self.conversation
+                                           )
+            async_to_sync(self.channel_layer.group_send)(
+            self.conversation_name,
+            {
+                "type": "chat_message_echo",
+                "name": self.user.username,
+                "message": MessageSerializer(message).data,
+            },
         )
+            notification_group_name = self.get_receiver().username + "__notifications"
+            async_to_sync(self.channel_layer.group_send)(
+    notification_group_name,
+    {
+        "type": "new_message_notification",
+        "name": self.user.username,
+        "message": MessageSerializer(message).data,
+    },
+)
 
-        self.accept()
+        print(message_type)
+        return super().receive_json(content, **kwargs)
+    def chat_message_echo(self, event):
+        self.send_json(event)
 
-    def disconnect(self, close_code):
-        # Leave room group
-        async_to_sync(self.channel_layer.group_discard)(
-            self.room_group_name, self.channel_name
-        )
 
-    # Receive message from WebSocket
-    def receive(self, text_data):
-        print("text",text_data)
-        data = json.loads(text_data)
-        print(data["command"],"printing command")
-        print(data,"this is data")
-        self.commands[data["command"]](self,data)
-
-    def send_chat_message(self,message):
-        # Send message to room group
-        async_to_sync(self.channel_layer.group_send)(
-            self.room_group_name, {"type": "chat_message", "message": message}
+    def new_message_notification(self, event):
+        self.send_json(event)
+
+    def unread_count(self, event):
+        self.send_json(event)
+
+
+def unread_count(self, event):
+        #in this we are passing the message to send group by method
+        print(event,"hai")
+        self.send_json(event)
+class NotificationConsumer(JsonWebsocketConsumer):
+    print("notification")
+    def __init__(self, *args, **kwargs):
+
+        super().__init__(args, kwargs)
+        self.notification_group_name = None
+        self.user = None
+
+    def connect(self):
+        self.user = self.scope["user"]
+        if not self.user.is_authenticated:
+            return
+
+        self.accept()
+        self.notification_group_name = self.user.username + "__notifications"
+        print(self.notification_group_name,"group name")
+        async_to_sync(self.channel_layer.group_add)(
+            self.notification_group_name,
+            self.channel_name,
         )
+        unread_count = Message.objects.filter(to_user=self.user, read=False).count()
+        self.send_json(
+    {
+        "type": "unread_count",
+        "unread_count": unread_count,
+    }
+)    # private notification group
+
+
+        # Send count of unread message
+    def disconnect(self, code):
+            async_to_sync(self.channel_layer.group_discard)(
+                self.notification_group_name,
+                self.channel_name,
+            )
+            return super().disconnect(code)
+    def new_message_notification(self, event):
+        self.send_json(event)
+
+    def unread_count(self, event):
+        self.send_json(event)
+
 
-    # Receive message from room group
-    def send_message(self,message):
-        self.send(text_data=json.dumps(message))
-    def chat_message(self, event):
-        message = event["message"]
-        print(message,"send chat")
 
-        # Send message to WebSocket
-        self.send(text_data=json.dumps(message))