tripwithbonus/ChatServiceApp/funcs.py

from .models import *
from django.db.models import Q
from django.http import HttpResponse, Http404, JsonResponse
from django.template import loader, RequestContext
from django.contrib.auth.decorators import login_required
from BaseModels.mailSender import techSendMail
from django.utils.translation import gettext as _
from datetime import datetime
from django.template.loader import render_to_string
from django.urls import reverse
import json
from datetime import datetime, time

def send_msg(data):
    from AuthApp.models import User
    res_Dict = {}
    msg = None

    try:

        data = json.loads(data)
        ticket = None

        tpl_name = 'blocks/profile/b_messages_container.html'

        if data['text']:

            if 'ticket_id' in data:
                ticket = MsgGroup.objects.get(id=data['ticket_id'])

            sender = User.objects.get(id=data['sender'])
            receiver = User.objects.get(id=data['receiver'])

            msg_create_kwargs = {}

            # если только что манагер присоединился к тикету
            if ticket:
                if not ticket.manager:
                    if sender.is_staff:
                        ticket.manager = sender
                    else:
                        ticket.manager = receiver

                    ticket.save()

                    kwargs = {
                        'sender': ticket.owner,
                        'receiver': ticket.manager,
                        'text': ticket.text,
                    }

                    kwargs.update({'group': ticket})

                    msg = Message.objects.create(**kwargs)
                    Message.objects.filter(id=msg.id).update(modifiedDT=ticket.createDT, createDT=ticket.createDT)

                res_Dict.update({
                    'ticket': ticket,
                    # 'cur_receiver': receiver,
                    # 'messages': get_messages_for_ticket(ticket),
                    # 'text': data['text'],
                    # 'modifiedDT': msg.modifiedDT
                })

                msg_create_kwargs.update({
                    'group': ticket,
                })

                res_Dict.update(get_ticketsDict_for_staff(sender))

            # if not msg:
            msg_create_kwargs.update({
                'sender': sender,
                'receiver': receiver,
                'text': data['text']
            })

            session_data = {
                'for_save_to_session': {
                    'user_alerts': {
                        'new_message': True
                    }
                }
            }

            receiver.user_profile.add_node_to_json_data(session_data, save=True)

            msg = Message.objects.create(**msg_create_kwargs)

            if ticket:
                msgs = get_messages_for_ticket(ticket)
            else:
                msgs = get_msgs_for_chat_w_users(sender, receiver)

            receivers, unread_msgs_count = get_chat_receivers_for_user(sender)

            res_Dict.update({
                'messages': msgs,
                'cur_receiver': receiver,
                'receivers': receivers,
                'text': data['text'],
                'modifiedDT': msgs[0].modifiedDT
            })

        html = render_to_string(tpl_name, res_Dict)
        return {'html': html, 'sender': data['sender']}

    except Exception as e:
        msg = f'send_msg_ajax Error = {str(e)}'
        return {'error': msg}




def get_chat_page_content_Dict(request, receiver_id=None):
    from AuthApp.models import User

    msgs = []
    try:
        cur_receiver = User.objects.get(id=receiver_id)

        msgs = get_msgs_for_chat_w_users(request.user, cur_receiver)
        msgs.filter(receiver=request.user).update(status='seen')

    except User.DoesNotExist:
        cur_receiver = None

    receivers, unread_msgs_count = get_chat_receivers_for_user(request.user)

    Dict = {
        'cur_receiver': cur_receiver,
        'messages': msgs,
        'receivers': receivers,
        'page': 'chat',
    }
    return Dict


def get_msgs_for_chat_w_users(user1, user2):

    msgs = Message.objects.filter(
        Q(sender=user1) | Q(receiver=user1),
        Q(sender=user2) | Q(receiver=user2),
        group=None
    ).order_by('-modifiedDT')
    return msgs

def get_chat_receivers_for_user(user, cur_receiver=None):
    msgs = Message.objects.filter(
        Q(sender=user) | Q(receiver=user),
        group=None
    ).order_by('-modifiedDT')#.select_related('sender', 'receiver').values('sender', 'receiver').distinct()

    receivers_list = []

    unread_msgs_count = 0

    for msg in msgs:
        if msg.receiver not in receivers_list and msg.receiver != user:
            msg.receiver.unread_msgs_count = 0
            msg.receiver.last_msg = msg.text
            receivers_list.append(msg.receiver)
        if msg.sender not in receivers_list and msg.sender != user:
            msg.sender.unread_msgs_count = 0
            receivers_list.append(msg.sender)
            msg.sender.last_msg = msg.text

        if msg.receiver == user:# and (not cur_receiver or msg.sender != cur_receiver):
            if msg.status == 'sended':
                i = receivers_list.index(msg.sender)
                receivers_list[i].unread_msgs_count += 1
                unread_msgs_count += 1

    return receivers_list, unread_msgs_count

    # receivers_list.extend((item.sender for item in receivers if item.sender != user))
    # receivers_list.extend((item.receiver for item in receivers if item.receiver != user))
    #
    # return list(set(receivers_list))


def get_tickets_Dict_by_manager(user):
    tickets = MsgGroup.objects.filter(enable=True, manager=user).order_by('-modifiedDT')

    Dict = {
        'tickets': tickets,
    }
    return Dict

def get_messages_for_ticket(ticket):
    return ticket.rel_messages_for_group.filter(enable=True).order_by('-modifiedDT')


def get_ticketsDict_for_staff(user):
    Dict = {
        'tickets_wo_manager': get_tickets_wo_manager(),
        'tickets_for_manager': get_tickets_for_manager(user),
    }
    return Dict

def get_tickets_wo_manager():

    tickets = MsgGroup.objects.filter(enable=True, manager=None).order_by('-modifiedDT')

    return tickets

def get_tickets_for_manager(user):

    tickets = MsgGroup.objects.filter(enable=True, manager=user).order_by('-modifiedDT')

    return tickets