models.py
```
from django.db import models
from django.contrib.auth import get_user_model

User = get_user_model()

class ChatParticipantsChannel(models.Model):
    channel = models.CharField(max_length=256)
    user = models.ForeignKey(User, on_delete=models.PROTECT)

    def __str__(self):
        return str(self.channel)

class ChatRoom(models.Model):
    name = models.CharField(max_length=50)
    last_message = models.CharField(max_length=1024, null=True)
    last_sent_user = models.ForeignKey(User, on_delete=models.PROTECT, null=True)

    def __str__(self):
        return self.name


class Messages(models.Model):
    room = models.ForeignKey(ChatRoom, on_delete=models.PROTECT)
    user = models.ForeignKey(User, on_delete=models.PROTECT)
    content = models.CharField(max_length=1024)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.content


class ChatRoomParticipants(models.Model):
    user = models.ManyToManyField(User, related_name='chatroom_users')
    room = models.ForeignKey(ChatRoom, on_delete=models.PROTECT)
```

consumers.py
```
import json
from channels.db import database_sync_to_async
from channels.generic.websocket import AsyncJsonWebsocketConsumer
from .models import ChatRoom, Messages, ChatParticipantsChannel
from channels.layers import get_channel_layer
from django.contrib.auth import get_user_model

User = get_user_model()


class ChatConsumer(AsyncJsonWebsocketConsumer):

    async def connect(self):
        self.user_id = self.scope['url_route']['kwargs']['user_id']

        await self.save_user_channel()
        await self.accept()

    async def disconnect(self, close_code):

        await self.delete_user_channel()

        # await self.channel_layer.group_discard(
        #     self.group_room_name,
        #     self.channel_name
        # )

        await self.disconnect(close_code)

    async def receive_json(self, text_data=None, byte_data=None):
        message = text_data['message']
        to_user = text_data['to_user']
        to_user_channel, to_user_id = await self.get_user_channel(to_user)

        channel_layer = get_channel_layer()

        self.group_name = f'{self.user_id}-{to_user}'
        await self.channel_layer.group_add(
            self.group_name,
            str(self.channel_name)
        )
        if to_user_channel != None and to_user_id != None:
            await self.channel_layer.group_add(
                self.group_name,
                str(to_user_channel)
            )


        await channel_layer.group_send(
            self.group_name, {
                'type': 'send.message',
                'from_user': self.user_id,
                'to_user': str(to_user_id),
                'message': message,
            }
        )

        await self.save_message(self.group_name, self.user, message)

    async def send_message(self, event):
        from_user = event['from_user']
        to_user = event['to_user']
        message = event['message']

        # print(1)
        print(event)

        await self.send(text_data=json.dumps({
            'from_user': from_user,
            'to_user': to_user,
            'message': message,
        }))

    @database_sync_to_async
    def get_user_channel(self, to_user):
        try:
            send_user_channel = ChatParticipantsChannel.objects.filter(
                user=to_user).latest('id')
            channel_name = send_user_channel
            user_id = send_user_channel.user.user_uid
        except Exception as e:
            channel_name = None
            user_id = None

        return channel_name, user_id

    @database_sync_to_async
    def save_user_channel(self):
        self.user = User.objects.get(user_uid=self.user_id)

        ChatParticipantsChannel.objects.create(
            user=self.user,
            channel=self.channel_name
        )

    @database_sync_to_async
    def delete_user_channel(self):
        ChatParticipantsChannel.objects.filter(user=self.user).delete()

    @database_sync_to_async
    def save_message(self, room, user, content):
        try:
            chatroom = ChatRoom.objects.get(name=str(room))
            chatroom.last_message = content
            chatroom.last_sent_user = self.user
            chatroom.save()
        except:
            chatroom = ChatRoom.objects.create(
                name=str(room), last_message=content, last_sent_user=self.user
            )

        Messages.objects.create(
            room=chatroom, user=self.user, content=content
        )


```