newosinadjango/osinaweb/osichat/consumers.py

from channels.generic.websocket import WebsocketConsumer 
from .models import * 
import json
from django.template.loader import render_to_string
from asgiref.sync import async_to_sync
from django.shortcuts import  get_object_or_404
import requests


class OsitcomVisitor(WebsocketConsumer):
    def connect(self):
        session = self.scope["session"]
        if not session.session_key:
            session.create()
        self.session_id = session.session_key

        async_to_sync(self.channel_layer.group_add)(
            'ositcom_visitors', self.channel_name
        )
        self.accept()
        self.visitor = None
       
    def disconnect(self, close_code):
        if self.visitor:
            self.visitor.left_date = datetime.now()
            self.visitor.save()
        async_to_sync(self.channel_layer.group_discard)(
            'ositcom_visitors', self.channel_name
        )
    def receive(self, text_data): 
        text_data_json = json.loads(text_data)
        event_type = text_data_json.get('event_type')
        if event_type == 'new_visitor':
            event = {
                'type': 'new_visitor_handler',
                'session_id': self.session_id ,
                'client_ip': text_data_json.get('client_ip'),
                'client_country': text_data_json.get('client_country'),
                'referrer':  text_data_json.get('referrer'),
                'url': text_data_json.get('url'),
                
            }
            async_to_sync(self.channel_layer.group_send)(
             'ositcom_visitors', event
            )

    def new_visitor_handler(self, event):
        visitor = Visitor.objects.create(
            session_id = event['session_id'],
            ip_address =  event['client_ip'],
            referrer =  event['referrer'],
            country =  event['client_country'],
            url = event['url'],
            visit_date = datetime.now(),
        )
        self.visitor = visitor





class OsitcomChatRoom(WebsocketConsumer):
    def connect(self):
        cookie_header = self.scope.get('headers', {})
        http_cookie = dict(cookie_header).get(b'cookie', b'').decode('utf-8')
        for cookie in http_cookie.split('; '):
            key, value = cookie.split('=')
            if key == 'sessionid':
                self.session_id = value
                break
        async_to_sync(self.channel_layer.group_add)(
            self.session_id, self.channel_name
        )
        self.accept()

        self.load_chat()
        

    def disconnect(self, close_code):
        async_to_sync(self.channel_layer.group_discard)(
            self.session_id, self.channel_name
        )


    def load_chat(self): 
        event = {
            'type': 'load_chat_handler',
        }
        async_to_sync(self.channel_layer.group_send)(
            self.session_id, event
        )

    def receive(self, text_data): 
        text_data_json = json.loads(text_data)
        event_type = text_data_json.get('event_type')
    
        if event_type == 'start_conversation':
            event = {
                'type': 'start_conversation_handler',
                'guest_name': text_data_json.get('guest_name'),
                'guest_mobile_number': text_data_json.get('guest_mobile_number'),
            }
            async_to_sync(self.channel_layer.group_send)(
             self.session_id, event
            )

        if event_type == 'send_message':
            event = {
                'type': 'send_message_handler',
                'body': text_data_json['message']
            }
            async_to_sync(self.channel_layer.group_send)(
             self.session_id, event
            )



    def load_chat_handler(self, event):
        chat_room = None
        chat_room_messages = None
        chat_room_guest = ChatRoomGuest.objects.filter(session_id=self.session_id).last()
        if chat_room_guest:
            chat_room = chat_room_guest.room
            self.chat_room = chat_room
            chat_room_messages = ChatMessage.objects.filter(room=chat_room).order_by('date_sent')
        context = {
            'chat_room': chat_room,
            'chat_room_messages': chat_room_messages,
        }
        html = render_to_string("chat-widget.html", context=context)
        self.send(text_data=json.dumps({
            'event_type': 'load_chat',
            'html': html,
        }))


    def start_conversation_handler(self, event):
        chat_room = ChatRoom.objects.create(
            name=f"Support: {self.session_id}",
            date_created = datetime.now()
        )
        chat_room_guest = ChatRoomGuest.objects.create(
            room=chat_room,
            name=event['guest_name'],
            mobile_number= event['guest_mobile_number'],
            session_id=self.session_id
        )
        context = {
            'chat_room': chat_room,
            'session_id':self.session_id
        }
        html = render_to_string("conversation.html", context=context)
        self.send(text_data=json.dumps({
            'event_type': 'start_conversation',
            'html': html,
        }))


    def send_message_handler(self, event):
        chat_message = ChatMessage.objects.create(
            room = self.chat_room,
            content=event['body'],
            date_sent = datetime.now()
        )
        context = {
            'chat_message': chat_message,
        }
        html = render_to_string("partials/message.html", context=context)
        self.send(text_data=json.dumps({
            'event_type': 'send_message',
            'html': html,
        }))