You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1185 lines
49 KiB
1185 lines
49 KiB
from django.shortcuts import render, redirect, get_object_or_404
|
|
from django.contrib.auth import authenticate, login as auth_login, logout
|
|
from .models import CustomUser, JobPosting,Message,FileDownload,MessageStatus
|
|
from skyonnadmin.models import ClientDetails,SubcompanyDetails,Locations,AddContact,InternalTeam
|
|
from django.contrib import messages
|
|
from django.http import JsonResponse
|
|
from django.db.models import Q
|
|
|
|
from django.contrib.auth.models import User
|
|
from django.http import HttpResponseRedirect
|
|
import os
|
|
from django.core.files.storage import FileSystemStorage
|
|
import json
|
|
from django.core.serializers.json import DjangoJSONEncoder
|
|
import uuid
|
|
from django.utils.timezone import now,localtime
|
|
import pytz
|
|
|
|
ist_timezone = pytz.timezone('Asia/Kolkata')
|
|
|
|
def home(request):
|
|
return render(request, 'user/home.html')
|
|
|
|
|
|
def create_user(request):
|
|
if request.method == 'POST':
|
|
# Handle signup form submission
|
|
first_name = request.POST.get('first_name')
|
|
last_name = request.POST.get('last_name')
|
|
phone = request.POST.get('phone')
|
|
phone2 = request.POST.get('phone_2')
|
|
company_email = request.POST.get('company_email')
|
|
personal_email = request.POST.get('personal_email')
|
|
address = request.POST.get('address')
|
|
work_location = request.POST.get('work_location')
|
|
role = request.POST.get('role')
|
|
password = request.POST.get('password')
|
|
picture = request.FILES.get('picture')
|
|
|
|
# Create user_id based on role
|
|
role_prefix = role[0].upper()
|
|
user_count = CustomUser.objects.filter(role=role).count() + 1
|
|
user_id = f"{role_prefix}{first_name[:3].upper()}{user_count:03}"
|
|
|
|
# Create the CustomUser object
|
|
user = CustomUser.objects.create(
|
|
first_name=first_name,
|
|
last_name=last_name,
|
|
phone=phone,
|
|
phone2=phone2,
|
|
company_email=company_email,
|
|
personal_email=personal_email,
|
|
address=address,
|
|
work_location=work_location,
|
|
role=role,
|
|
user_id=user_id
|
|
)
|
|
user.set_password(password)
|
|
user.picture = picture
|
|
user.save()
|
|
user.backend = 'user.backend.PhoneAuthenticationBackend'
|
|
auth_login(request, user)
|
|
|
|
return redirect('dashboard', user_id=user.user_id)
|
|
else:
|
|
return render(request, 'user/home.html')
|
|
|
|
|
|
# def user_login(request):
|
|
# if request.method == 'POST':
|
|
# phone = request.POST.get('phone')
|
|
# password = request.POST.get('password')
|
|
#
|
|
# user = authenticate(request, phone=phone, password=password)
|
|
# # print(phone, password, user)
|
|
# if user is not None:
|
|
# auth_login(request, user)
|
|
# user = CustomUser.objects.filter(phone=phone).first()
|
|
# if user:
|
|
# # print(user.user_id)
|
|
# return redirect('dashboard', user_id=user.user_id)
|
|
# else:
|
|
# messages.error(request, 'No user found for the provided phone number.')
|
|
# else:
|
|
# messages.error(request, 'Invalid phone number or password.')
|
|
#
|
|
# return render(request, 'user/home.html')
|
|
|
|
|
|
def user_login(request):
|
|
if request.method == 'POST':
|
|
phone = request.POST.get('phone')
|
|
password = request.POST.get('password')
|
|
|
|
if not phone and 'phone' in request.POST:
|
|
return JsonResponse({'error': 'Please fill the phone number field.'}, status=400)
|
|
if not password and 'password' in request.POST: # Validate password if it's present
|
|
return JsonResponse({'error': 'Please fill the password field.'}, status=400)
|
|
|
|
user = InternalTeam.objects.filter(Login=phone).first()
|
|
if user is None:
|
|
return JsonResponse({'error': 'Incorrect Email.'}, status=404)
|
|
|
|
if password:
|
|
match = InternalTeam.objects.filter(Login=phone,Password=password).first()
|
|
if not match:
|
|
return JsonResponse({'error': 'Incorrect password.'}, status=401)
|
|
|
|
return JsonResponse(
|
|
{'success': 'Login successful', 'redirect_url': f'/user/dashboard/{user.user_id}'})
|
|
|
|
return JsonResponse({'success': 'Phone number is valid.'}, status=200)
|
|
|
|
return JsonResponse({'error': 'Invalid request method.'}, status=405)
|
|
|
|
|
|
def dashboard(request, user_id):
|
|
# Retrieve the manager object using manager_id
|
|
user = get_object_or_404(InternalTeam, user_id=user_id)
|
|
print('user_id:',user_id)
|
|
|
|
# Get the manager's first name
|
|
first_name = user.FirstName.capitalize()
|
|
last_name = user.LastName.capitalize()
|
|
full_name = f"{first_name}'s"
|
|
|
|
return render(request, 'user/dashboard.html', {'first_name': full_name, 'user_id': user_id})
|
|
|
|
# def dashboard(request, user_id):
|
|
# # Retrieve the manager object using manager_id
|
|
# user = get_object_or_404(CustomUser, user_id=user_id)
|
|
# print('user_id:', user_id)
|
|
#
|
|
# # Get the manager's first name
|
|
# first_name = user.FirstName.capitalize()
|
|
# full_name = f"{first_name}'s"
|
|
# print(full_name)
|
|
#
|
|
# if user.role == 'manager':
|
|
# print("hiii")
|
|
# return render(request, 'user/test.html', {'first_name': full_name, 'user_id': user_id})
|
|
#
|
|
# if user.role == 'recruiter':
|
|
# return render(request, 'recruiter/recruiter_dashboard.html', {'first_name': full_name, 'user_id': user_id})
|
|
|
|
|
|
def new_job_posting(request):
|
|
locations = Locations.objects.all()
|
|
clients = ClientDetails.objects.all()
|
|
return render(request, 'user/new_job_posting.html', {'clients': clients,'locations':locations})
|
|
|
|
|
|
def add_recruiter(request):
|
|
user_id = request.GET.get('user_id', None)
|
|
print(user_id)
|
|
context = {'user_id': user_id}
|
|
return render(request, 'user/add_recruiter.html', context)
|
|
|
|
|
|
def logout_view(request):
|
|
logout(request)
|
|
return redirect('home')
|
|
|
|
|
|
# def save_job_posting(request):
|
|
# if request.method == 'POST':
|
|
# client = request.POST.get('Client')
|
|
# spoc = request.POST.get('SPOC')
|
|
# start_date = request.POST.get('StartDate')
|
|
# budget_max = request.POST.get('BudgetMax')
|
|
# budget_min = request.POST.get('BudgetMin')
|
|
# job_description = request.POST.get('JobDescription')
|
|
# special_instructions = request.POST.get('SpecialInstructions')
|
|
# job_id = request.POST.get('JobID')
|
|
# spoc_2 = request.POST.get('SPOC2')
|
|
# close_date = request.POST.get('CloseDate')
|
|
# locations = request.POST.getlist('Location') # Use getlist to handle multiple selections
|
|
# no_of_posting = request.POST.get('NoOfPosting')
|
|
# job_type = request.POST.get('Type')
|
|
# header = request.POST.get('Header')
|
|
# experience_in_years = request.POST.get('Experience_in_Yrs')
|
|
#
|
|
# job_posting = JobPosting(
|
|
# client=client,
|
|
# spoc=spoc,
|
|
# budget_min=budget_min,
|
|
# start_date=start_date,
|
|
# budget_max=budget_max,
|
|
# job_description=job_description,
|
|
# special_instructions=special_instructions,
|
|
# job_id=job_id,
|
|
# spoc_2=spoc_2,
|
|
# close_date=close_date,
|
|
# no_of_posting=no_of_posting,
|
|
# job_type=job_type,
|
|
# header=header,
|
|
# experience_in_years=experience_in_years
|
|
# )
|
|
# job_posting.set_locations(locations) # Save the locations as a comma-separated string
|
|
# job_posting.save()
|
|
# return JsonResponse({'status': 'success', 'message': 'Job posting saved successfully.'})
|
|
#
|
|
# return redirect('error_url')
|
|
#
|
|
|
|
def save_job_posting(request):
|
|
if request.method == 'POST':
|
|
# Extract data from the form
|
|
Client = request.POST.get('Client', '')
|
|
JobID = request.POST.get('JobID', '')
|
|
Location = request.POST.get('Location', '')
|
|
SPOC = request.POST.get('SPOC', '')
|
|
SPOC2 = request.POST.get('SPOC2', '')
|
|
StartDate = request.POST.get('StartDate', '')
|
|
CloseDate = request.POST.get('CloseDate', '')
|
|
BudgetMin = request.POST.get('BudgetMin', '')
|
|
timePeriod = request.POST.get('timePeriod', '')
|
|
minAmount = request.POST.get('minAmount', '')
|
|
maxAmount = request.POST.get('maxAmount', '')
|
|
Header = request.POST.get('Header', '')
|
|
JobDescription = request.POST.get('JobDescription', '')
|
|
Experience_in_Yrs = request.POST.get('Experience', '')
|
|
NoOfPosting = request.POST.get('NoOfPosting', '')
|
|
Qualification = request.POST.get('Qualification', '').upper()
|
|
SpecialInstructions = request.POST.get('SpecialInstructions', '')
|
|
|
|
JD = None
|
|
slice_JD = None
|
|
if request.FILES.get('JD'):
|
|
myfile = request.FILES['JD']
|
|
file_extension = os.path.splitext(myfile.name)[1] # Get the file extension
|
|
filename = f"{JobID}{file_extension}" # Create the new filename using job_id
|
|
fs = FileSystemStorage()
|
|
filename = fs.save(filename, myfile)
|
|
JD = fs.url(filename) # Get the URL to the file
|
|
slice_JD = JD[7:]
|
|
|
|
jobposting = JobPosting(
|
|
Client=Client,
|
|
JobID=JobID,
|
|
Location=Location,
|
|
SPOC=SPOC,
|
|
SPOC2=SPOC2,
|
|
StartDate=StartDate,
|
|
CloseDate=CloseDate,
|
|
BudgetMin=BudgetMin,
|
|
timePeriod=timePeriod,
|
|
minAmount=minAmount,
|
|
maxAmount=maxAmount,
|
|
Qualification=Qualification,
|
|
Header=Header,
|
|
JobDescription=JobDescription,
|
|
Experience_in_Yrs=Experience_in_Yrs,
|
|
NoOfPosting=NoOfPosting,
|
|
SpecialInstructions=SpecialInstructions,
|
|
JD=JD,
|
|
slice_JD=slice_JD
|
|
)
|
|
jobposting.save()
|
|
print(jobposting)
|
|
|
|
admin_id = request.GET.get('admin_id', None)
|
|
print(admin_id)
|
|
|
|
return JsonResponse({'status': 'success', 'message': 'Job_posting saved successfully.'})
|
|
|
|
else:
|
|
return JsonResponse({'status': 'error', 'message': 'Invalid request method'}, status=400)
|
|
|
|
|
|
|
|
def create_recruiter(request):
|
|
if request.method == 'POST':
|
|
# Handle signup form submission
|
|
# print(request.post)
|
|
first_name = request.POST.get('first_name')
|
|
last_name = request.POST.get('last_name')
|
|
phone = request.POST.get('phone')
|
|
phone2 = request.POST.get('phone_2')
|
|
company_email = request.POST.get('company_email')
|
|
personal_email = request.POST.get('personal_email')
|
|
address = request.POST.get('address')
|
|
work_location = request.POST.get('work_location')
|
|
role = "recruiter" # request.POST.get('role')
|
|
password = request.POST.get('password')
|
|
picture = request.FILES.get('picture')
|
|
manager_assigned = request.POST.get('manager_assigned', None)
|
|
print(manager_assigned, 1)
|
|
# Create user_id based on role
|
|
role_prefix = role[0].upper()
|
|
user_count = CustomUser.objects.filter(role=role).count() + 1
|
|
user_id = f"{role_prefix}{first_name[:3].upper()}{user_count:03}"
|
|
|
|
# Create the CustomUser object
|
|
user = CustomUser.objects.create(
|
|
first_name=first_name,
|
|
last_name=last_name,
|
|
phone=phone,
|
|
phone2=phone2,
|
|
company_email=company_email,
|
|
personal_email=personal_email,
|
|
address=address,
|
|
work_location=work_location,
|
|
role=role,
|
|
user_id=user_id,
|
|
manager_assigned=manager_assigned
|
|
)
|
|
user.set_password(password)
|
|
user.picture = picture
|
|
user.save()
|
|
return redirect('dashboard', user_id=manager_assigned)
|
|
# return JsonResponse({'success': True, 'message': 'Recruiter added successfully!'})
|
|
|
|
else:
|
|
messages.success(request, 'Data saved successfully.')
|
|
|
|
# Instead of redirecting, render the same form page again
|
|
return render(request, 'user/add_recruiter.html')
|
|
|
|
|
|
# def send_message(request, recipient_id):
|
|
# recipient = get_object_or_404(User, pk=recipient_id)
|
|
#
|
|
# if request.method == 'POST':
|
|
# # Retrieve form data
|
|
# subject = request.POST.get('subject')
|
|
# body = request.POST.get('body')
|
|
# # attachment = request.FILES.get('attachment') # Retrieve file if uploaded
|
|
#
|
|
# attachment = None
|
|
# if request.FILES.get('attachment'):
|
|
# myfile = request.FILES['attachment']
|
|
# file_name = os.path.splitext(myfile.name)[0] # Get the file extension
|
|
# filename = file_name # Create the new filename using job_id
|
|
# fs = FileSystemStorage()
|
|
# filename = fs.save(filename, myfile)
|
|
# attachment = fs.url(filename) # Get the URL to the file
|
|
# print(attachment)
|
|
#
|
|
#
|
|
# # Create a new message object
|
|
# message = Message.objects.create(
|
|
# sender=request.user, # Current logged-in user
|
|
# recipient=recipient, # Recipient
|
|
# subject=subject, # Subject
|
|
# body=body, # Body of the message
|
|
# attachment=attachment
|
|
# )
|
|
#
|
|
# return JsonResponse({
|
|
# 'status': 'success',
|
|
# 'message': 'Message sent successfully.',
|
|
# 'message_id': message.id, # Optional: send back message ID or any other info
|
|
# 'attachment_url': attachment, # Send file URL if uploaded
|
|
# })
|
|
#
|
|
# # If GET request, show the message composition page
|
|
# return render(request, 'send_message.html', {'recipient': recipient})
|
|
|
|
def mark_as_read(request, message_id):
|
|
message = get_object_or_404(Message, pk=message_id, recipient=request.user)
|
|
message.is_read = True
|
|
message.save()
|
|
return redirect('messages')
|
|
|
|
|
|
def get_locations(request):
|
|
if request.method == 'GET':
|
|
client = request.GET.get('Client')
|
|
jobposting_locations = JobPosting.objects.filter(Client=client).values_list('Location').distinct()
|
|
client_locations = ClientDetails.objects.filter(parent_company=client).values_list('location_Id').distinct()
|
|
subclient_locations = SubcompanyDetails.objects.filter(parent_company=client).values_list('location_id').distinct()
|
|
|
|
locations = set(jobposting_locations) | set(client_locations) | set(subclient_locations)
|
|
|
|
location_list = list(locations)
|
|
return JsonResponse(location_list, safe=False)
|
|
else:
|
|
return JsonResponse({'error': 'Invalid request method'}, status=400)
|
|
|
|
|
|
def get_client_details(request):
|
|
if request.method == 'GET':
|
|
client = request.GET.get('client')
|
|
try:
|
|
# Retrieve a single ClientDetails object
|
|
client_obj = ClientDetails.objects.get(parent_company=client)
|
|
client_data = {
|
|
'parent_company': client_obj.parent_company,
|
|
'GST_No': client_obj.GST_No,
|
|
'Location_Id': client_obj.location_Id,
|
|
'Address_1': client_obj.address_1,
|
|
'Address_2': client_obj.address_2,
|
|
'City': client_obj.City,
|
|
'State': client_obj.state,
|
|
'Pincode': client_obj.Pincode,
|
|
'Country': client_obj.country
|
|
}
|
|
return JsonResponse(client_data)
|
|
except ClientDetails.DoesNotExist:
|
|
return JsonResponse({'error': 'Client not found'}, status=404)
|
|
else:
|
|
return JsonResponse({'error': 'Invalid request method'}, status=400)
|
|
|
|
def new_login(request):
|
|
if request.method == 'POST':
|
|
Login_id = request.POST.get('phone')
|
|
password = request.POST.get('password')
|
|
|
|
print(Login_id, password)
|
|
|
|
user = InternalTeam.objects.filter(Login=Login_id,Password=password).first()
|
|
print(user)
|
|
if user is not None:
|
|
|
|
print(user.user_id)
|
|
return redirect('dashboard', user_id=user.user_id)
|
|
|
|
else:
|
|
messages.error(request, 'Invalid phone number or password.')
|
|
|
|
return render(request, 'user/home.html')
|
|
|
|
def new_job_posting(request):
|
|
clients = ClientDetails.objects.all()
|
|
user_id = request.GET.get('user_id', None)
|
|
print('opened newJobPosting:',user_id)
|
|
user = get_object_or_404(InternalTeam,user_id=user_id)
|
|
print(user.Level)
|
|
|
|
restricted =bool(int((user.Level)[6:]) < 5)
|
|
|
|
if restricted==True:
|
|
return render(request, 'user/new_job_posting.html', {'user': user, 'clients': clients, 'user_id': user_id, 'restricted': True})
|
|
else:
|
|
return render(request, 'user/new_job_posting.html', {'user': user,'clients': clients,'user_id': user_id, 'restricted': False})
|
|
|
|
|
|
def get_contacts(request):
|
|
if request.method == 'GET':
|
|
client = request.GET.get('Client')
|
|
print(client)
|
|
SPOC_Details = AddContact.objects.filter(Company=client).values('FirstName','LastName')
|
|
|
|
SPOC_Details_list = list(SPOC_Details)
|
|
return JsonResponse(SPOC_Details_list, safe=False)
|
|
else:
|
|
return JsonResponse({'error': 'Invalid request'})
|
|
|
|
def validate_field(request):
|
|
if request.method == 'GET':
|
|
email = request.GET.get('Email')
|
|
phone_number = request.GET.get('Phone_number')
|
|
response = {
|
|
'exists': False
|
|
}
|
|
if email and AddContact.objects.filter(Email=email).exists():
|
|
response['exists'] = True
|
|
elif phone_number and AddContact.objects.filter(Phone_number=phone_number).exists():
|
|
response['exists'] = True
|
|
return JsonResponse(response)
|
|
|
|
|
|
def all_job_postings(request):
|
|
user_id = request.GET.get('user_id', None)
|
|
print('opened allJobPosting:', user_id)
|
|
clients = ClientDetails.objects.all()
|
|
user = get_object_or_404(InternalTeam, user_id=user_id)
|
|
print(user.Level)
|
|
|
|
restricted = bool(int((user.Level)[6:]) < 5)
|
|
|
|
if restricted == True:
|
|
job_postings = JobPosting.objects.all()
|
|
return render(request, 'user/all_job_postings.html',
|
|
{'user': user, 'clients': clients, 'user_id': user_id, 'restricted': True,'job_postings': job_postings})
|
|
else:
|
|
query = request.GET.get('query', '') # Get the query parameter if it exists
|
|
|
|
if query:
|
|
job_postings = (JobPosting.objects.filter(job_id__icontains=query) |
|
|
JobPosting.objects.filter(spoc__icontains=query) |
|
|
JobPosting.objects.filter(client__icontains=query ))
|
|
else:
|
|
job_postings = JobPosting.objects.all()
|
|
|
|
return render(request, 'user/all_job_postings.html',
|
|
{'user': user, 'clients': clients, 'user_id': user_id, 'restricted': False,'job_postings': job_postings})
|
|
|
|
|
|
def get_jobPosting(request):
|
|
if request.method == 'GET':
|
|
jobId = request.GET.get('JobId')
|
|
try:
|
|
# Retrieve a single ClientDetails object
|
|
job_obj = JobPosting.objects.get(JobID=jobId)
|
|
job_data = {
|
|
'Client': job_obj.Client,
|
|
'JobID': job_obj.JobID,
|
|
'Location': job_obj.Location,
|
|
'SPOC': job_obj.SPOC,
|
|
'SPOC2': job_obj.SPOC2,
|
|
'NoOfPosting': job_obj.NoOfPosting,
|
|
'StartDate': job_obj.StartDate,
|
|
'CloseDate': job_obj.CloseDate,
|
|
'Experience_in_Yrs': job_obj.Experience_in_Yrs,
|
|
'BudgetMin': job_obj.BudgetMin,
|
|
'Qualification': job_obj.Qualification,
|
|
'Header': job_obj.Header,
|
|
'JobDescription': job_obj.JobDescription,
|
|
'SpecialInstructions': job_obj.SpecialInstructions
|
|
}
|
|
return JsonResponse(job_data)
|
|
except JobPosting.DoesNotExist:
|
|
return JsonResponse({'error': 'Job Posting not found'}, status=404)
|
|
else:
|
|
return JsonResponse({'error': 'Invalid request method'}, status=400)
|
|
|
|
|
|
|
|
def messages(request):
|
|
user_id = request.GET.get('user_id','')
|
|
current_user_id = InternalTeam.objects.filter(user_id=user_id).values_list('Email1', flat=True).first()
|
|
teams = InternalTeam.objects.exclude(Email1=current_user_id)
|
|
return render(request,'user/messages.html',{'user_id': user_id,'current_user_id': current_user_id, 'teams':teams})
|
|
|
|
def generate_unique_message_id(firstname):
|
|
"""Generates a unique message_id by checking its existence in the database."""
|
|
prefix = firstname[:3].upper()
|
|
while True:
|
|
unique_id = str(uuid.uuid4().int)[:4] # Generate a random 4-digit number
|
|
message_id = prefix + unique_id
|
|
if not Message.objects.filter(message_id=message_id).exists():
|
|
print(message_id,'created message_id')
|
|
return message_id
|
|
|
|
def send_message(request):
|
|
if request.method == 'POST':
|
|
try:
|
|
current_user = request.GET.get('user_id', None)
|
|
current_user_id = InternalTeam.objects.filter(user_id=current_user).values_list('Email1', flat=True).first()
|
|
|
|
recipients = request.POST.get('toField').split(',') # Multiple emails separated by commas
|
|
print(recipients)
|
|
subject = request.POST.get('subject')
|
|
body = request.POST.get('message')
|
|
attachment = request.FILES.get('attachment') # Using .get() to avoid KeyError
|
|
attachment_url = None
|
|
if attachment:
|
|
myfile = request.FILES['attachment']
|
|
file_name, file_extension = os.path.splitext(myfile.name)
|
|
fs = FileSystemStorage()
|
|
|
|
# Save the file with a unique filename
|
|
filename = fs.save(file_name, attachment)
|
|
attachment_url = fs.url(filename)
|
|
|
|
sender = current_user_id
|
|
sender_id = get_object_or_404(InternalTeam, Email1=sender)
|
|
|
|
sender_fullname = sender_id.FullName
|
|
firstname = InternalTeam.objects.filter(user_id=current_user).values_list('FirstName', flat=True).first()
|
|
|
|
message_id = generate_unique_message_id(firstname)
|
|
|
|
recipient_fullnames = []
|
|
recipient_emails = []
|
|
for recipient_email in recipients: # Split by comma
|
|
recipient_id = get_object_or_404(InternalTeam, Email1=recipient_email)
|
|
print(recipient_id)
|
|
|
|
recipient_emails.append(recipient_id)
|
|
recipient_fullnames.append(recipient_id.FullName)
|
|
|
|
recipient_details = [{'email': r.Email1, 'fullname': r.FullName} for r in recipient_emails]
|
|
|
|
message = Message(
|
|
sender=sender_id,
|
|
subject=subject,
|
|
body=body,
|
|
is_read=False,
|
|
sender_fullname=sender_fullname,
|
|
recipient_fullname=", ".join(recipient_fullnames),
|
|
message_id=message_id,
|
|
attachment=attachment
|
|
)
|
|
message.save()
|
|
message.recipient.set(recipient_emails)
|
|
|
|
return JsonResponse({
|
|
'status': 'success',
|
|
'message': 'Message sent successfully.',
|
|
'details': {
|
|
'subject': subject,
|
|
'recipients': recipient_details,
|
|
'sender_fullname': sender_fullname,
|
|
'recipient_fullname': ",".join(recipient_fullnames),
|
|
'body': body,
|
|
'sent_at': message.sent_at.strftime('%Y-%m-%d %H:%M:%S'),
|
|
'message_id': message.message_id,
|
|
'attachment': attachment_url
|
|
}
|
|
})
|
|
except Exception as e:
|
|
print("Error occurred:", str(e)) # Print error to console for debugging
|
|
return JsonResponse({'status': 'error', 'message': 'Failed to send message'}, status=500)
|
|
|
|
else:
|
|
return JsonResponse({'status': 'error', 'message': 'Invalid request method'}, status=400)
|
|
|
|
def render_messages(request):
|
|
current_user = request.GET.get('user_id', None)
|
|
current_user_id = get_object_or_404(InternalTeam, user_id=current_user)
|
|
|
|
# Fetch all messages for the user
|
|
inbox_messages = Message.objects.filter(
|
|
Q(recipient=current_user_id),
|
|
is_trashed=False
|
|
).order_by('-sent_at')
|
|
|
|
# Dictionary to group messages by the main message
|
|
grouped_messages = {}
|
|
|
|
for message in inbox_messages:
|
|
# Find the main message for grouping
|
|
main_message = message
|
|
while main_message.reply_to:
|
|
main_message = main_message.reply_to
|
|
|
|
# Check if the main message already has a group
|
|
if main_message.id not in grouped_messages:
|
|
grouped_messages[main_message.id] = {
|
|
'main_message': main_message,
|
|
'replies': [],
|
|
}
|
|
|
|
# Add the current message to the main message's replies
|
|
if message != main_message:
|
|
grouped_messages[main_message.id]['replies'].append(message)
|
|
|
|
# Prepare the response
|
|
messages_data = []
|
|
for group in grouped_messages.values():
|
|
main_message = group['main_message']
|
|
|
|
# Sort replies by sent_at
|
|
sorted_replies = sorted(group['replies'], key=lambda x: x.sent_at)
|
|
|
|
# Function to get attachment details
|
|
def get_attachment_data(attachment):
|
|
if not attachment:
|
|
return []
|
|
try:
|
|
fs = FileSystemStorage()
|
|
attachment_url = fs.url(attachment.name)
|
|
file_path = fs.path(attachment.name)
|
|
file_size = os.path.getsize(file_path)
|
|
return [{
|
|
'filename': attachment.name.split('/')[-1],
|
|
'url': attachment_url,
|
|
'size': file_size
|
|
}]
|
|
except Exception as e:
|
|
print(f"Error retrieving attachment: {e}")
|
|
return []
|
|
|
|
def get_first_downloaded(message_id):
|
|
file_download = FileDownload.objects.filter(message_id=message_id).first()
|
|
if file_download:
|
|
return localtime(file_download.first_downloaded).strftime('%m/%d/%Y, %I:%M:%S %p')
|
|
return None
|
|
|
|
def get_last_downloaded(message_id):
|
|
file_download = FileDownload.objects.filter(message_id=message_id).first()
|
|
if file_download:
|
|
return localtime(file_download.last_downloaded).strftime('%m/%d/%Y, %I:%M:%S %p')
|
|
return None
|
|
|
|
def get_message_status(message, user):
|
|
status = MessageStatus.objects.filter(message=message, user=user).first()
|
|
if status:
|
|
return status.is_read, localtime(status.seen_time).strftime('%m/%d/%Y, %I:%M:%S %p') if status.seen_time else "00:00:00"
|
|
return False, "00:00:00"
|
|
|
|
replies_data = [{
|
|
'sender_fullname': reply.sender.FullName,
|
|
'body': reply.body,
|
|
'sent_at': localtime(reply.sent_at).strftime('%m/%d/%Y, %I:%M:%S %p'),
|
|
'message_id': reply.message_id,
|
|
'parent_message_id': reply.reply_to.message_id if reply.reply_to else None,
|
|
'main_message_id': main_message.message_id, # Ensures main message ID is always available
|
|
'is_read': get_message_status(reply, current_user_id)[0],
|
|
'seen_time': get_message_status(reply, current_user_id)[1],
|
|
'attachment': get_attachment_data(reply.attachment),
|
|
'first_downloaded': get_first_downloaded(reply.message_id),
|
|
'last_downloaded': get_last_downloaded(reply.message_id),
|
|
} for reply in sorted_replies]
|
|
|
|
latest_message = sorted_replies[-1] if sorted_replies else main_message
|
|
|
|
messages_data.append({
|
|
'sender_fullname': main_message.sender.FullName,
|
|
'sender_id': main_message.sender_id,
|
|
'recipient_fullnames': [recipient.FullName for recipient in main_message.recipient.all()],
|
|
'recipient_emails': [recipient.Email1 for recipient in main_message.recipient.all()],
|
|
'subject': main_message.subject,
|
|
'body': main_message.body,
|
|
'sent_at': localtime(main_message.sent_at).strftime('%m/%d/%Y, %I:%M:%S %p'),
|
|
'message_id': main_message.message_id,
|
|
'parent_message_id': main_message.reply_to.message_id if main_message.reply_to else None,
|
|
'main_message_id': main_message.message_id, # Ensures the root message ID is stored
|
|
'is_read': get_message_status(main_message, current_user_id)[0],
|
|
'seen_time': get_message_status(main_message, current_user_id)[1],
|
|
'attachment': get_attachment_data(main_message.attachment),
|
|
'replies': replies_data,
|
|
'latest_message': {
|
|
'sender_fullname': latest_message.sender.FullName,
|
|
'subject': latest_message.subject,
|
|
'body': latest_message.body,
|
|
'sent_at': localtime(latest_message.sent_at).strftime('%m/%d/%Y, %I:%M:%S %p'),
|
|
'message_id': latest_message.message_id,
|
|
'is_read': get_message_status(latest_message, current_user_id)[0],
|
|
'seen_time': get_message_status(latest_message, current_user_id)[1],
|
|
'attachment': get_attachment_data(latest_message.attachment),
|
|
'first_downloaded': get_first_downloaded(latest_message.message_id),
|
|
'last_downloaded': get_last_downloaded(latest_message.message_id),
|
|
}
|
|
})
|
|
|
|
return JsonResponse({'inbox_messages': messages_data})
|
|
def render_sent_messages(request):
|
|
current_user = request.GET.get('user_id', None)
|
|
current_user_id = get_object_or_404(InternalTeam, user_id=current_user)
|
|
|
|
# Fetch all messages for the user
|
|
sent_messages = Message.objects.filter(
|
|
Q(sender=current_user_id),
|
|
is_trashed=False
|
|
).order_by('-sent_at')
|
|
|
|
# Dictionary to group messages by the main message
|
|
grouped_messages = {}
|
|
|
|
for message in sent_messages:
|
|
# Find the main message for grouping
|
|
main_message = message
|
|
while main_message.reply_to:
|
|
main_message = main_message.reply_to
|
|
|
|
# Check if the main message already has a group
|
|
if main_message.id not in grouped_messages:
|
|
grouped_messages[main_message.id] = {
|
|
'main_message': main_message,
|
|
'replies': [],
|
|
}
|
|
|
|
# Add the current message to the main message's replies
|
|
if message != main_message:
|
|
grouped_messages[main_message.id]['replies'].append(message)
|
|
|
|
# Prepare the response
|
|
messages_data = []
|
|
for group in grouped_messages.values():
|
|
main_message = group['main_message']
|
|
|
|
# Sort replies by sent_at
|
|
sorted_replies = sorted(group['replies'], key=lambda x: x.sent_at)
|
|
|
|
# Integrate get_attachment_data
|
|
def get_attachment_data(attachment):
|
|
if not attachment:
|
|
return []
|
|
try:
|
|
fs = FileSystemStorage()
|
|
attachment_url = fs.url(attachment.name)
|
|
file_path = fs.path(attachment.name)
|
|
file_size = os.path.getsize(file_path)
|
|
return [{
|
|
'filename': attachment.name.split('/')[-1],
|
|
'url': attachment_url,
|
|
'size': file_size
|
|
}]
|
|
except Exception as e:
|
|
print(f"Error retrieving attachment: {e}")
|
|
return []
|
|
|
|
def get_first_downloaded(message_id):
|
|
file_download = FileDownload.objects.filter(message_id=message_id).first()
|
|
if file_download:
|
|
return localtime(file_download.first_downloaded).strftime('%m/%d/%Y, %I:%M:%S %p')
|
|
return None
|
|
|
|
def get_last_downloaded(message_id):
|
|
file_download = FileDownload.objects.filter(message_id=message_id).first()
|
|
if file_download:
|
|
return localtime(file_download.last_downloaded).strftime('%m/%d/%Y, %I:%M:%S %p')
|
|
return None
|
|
|
|
replies_data = [{
|
|
'sender_fullname': reply.sender.FullName,
|
|
'body': reply.body,
|
|
'sent_at': localtime(reply.sent_at).strftime('%m/%d/%Y, %I:%M:%S %p'),
|
|
'message_id': reply.message_id,
|
|
'is_read': reply.is_read,
|
|
'attachment': get_attachment_data(reply.attachment),
|
|
'first_downloaded': get_first_downloaded(reply.message_id),
|
|
'last_downloaded': get_last_downloaded(reply.message_id),
|
|
} for reply in sorted_replies]
|
|
|
|
latest_message = sorted_replies[-1] if sorted_replies else main_message
|
|
|
|
messages_data.append({
|
|
'sender_fullname': main_message.sender.FullName,
|
|
'sender_id': main_message.sender_id,
|
|
'recipient_fullnames': [recipient.FullName for recipient in main_message.recipient.all()],
|
|
'recipient_emails': [recipient.Email1 for recipient in main_message.recipient.all()],
|
|
'subject': main_message.subject,
|
|
'body': main_message.body,
|
|
'sent_at': localtime(main_message.sent_at).strftime('%m/%d/%Y, %I:%M:%S %p'),
|
|
'message_id': main_message.message_id,
|
|
'is_read': main_message.is_read,
|
|
'attachment': get_attachment_data(main_message.attachment),
|
|
'replies': replies_data,
|
|
'latest_message': {
|
|
'sender_fullname': latest_message.sender.FullName,
|
|
'recipient_fullnames': [recipient.FullName for recipient in latest_message.recipient.all()],
|
|
'subject': latest_message.subject,
|
|
'body': latest_message.body,
|
|
'sent_at': localtime(latest_message.sent_at).strftime('%m/%d/%Y, %I:%M:%S %p'),
|
|
'message_id': latest_message.message_id,
|
|
'is_read': latest_message.is_read,
|
|
'attachment': get_attachment_data(latest_message.attachment),
|
|
'first_downloaded': get_first_downloaded(latest_message.message_id),
|
|
'last_downloaded': get_last_downloaded(latest_message.message_id),
|
|
}
|
|
})
|
|
|
|
return JsonResponse({'sent_messages': messages_data})
|
|
|
|
def update_message_read_status(request, message_id):
|
|
current_user_id = request.GET.get('user_id', None)
|
|
current_user = get_object_or_404(InternalTeam, user_id=current_user_id)
|
|
|
|
if request.method == 'POST':
|
|
message = get_object_or_404(Message, message_id=message_id)
|
|
|
|
# Ensure the current user is a recipient of the message
|
|
if current_user not in message.recipient.all():
|
|
return JsonResponse({'success': False, 'error': 'User is not a recipient of this message.'}, status=400)
|
|
|
|
# Fetch or create the read status for the current user
|
|
status, created = MessageStatus.objects.get_or_create(
|
|
message=message,
|
|
user=current_user,
|
|
defaults={
|
|
'is_read': False, # Initially set is_read as False
|
|
'seen_time': None # Initially set seen_time as None
|
|
}
|
|
)
|
|
# If the message is being read for the first time, update the read status
|
|
if not status.is_read:
|
|
status.is_read = True
|
|
status.seen_time = now()
|
|
status.save()
|
|
|
|
return JsonResponse({
|
|
'success': True,
|
|
'message': f'Message {message_id} updated successfully',
|
|
'is_read': status.is_read,
|
|
'seen_time': localtime(status.seen_time).strftime('%m/%d/%Y, %I:%M:%S %p') if status.seen_time else "00:00:00"
|
|
})
|
|
|
|
return JsonResponse({'success': False, 'error': 'Invalid request method'}, status=400)
|
|
|
|
|
|
def get_message_status(request, message_id):
|
|
message = get_object_or_404(Message, message_id=message_id)
|
|
current_user = request.GET.get('user_id')
|
|
current_user_id = get_object_or_404(InternalTeam,user_id=current_user)
|
|
|
|
recipient_status = []
|
|
for recipient in message.recipient.all():
|
|
seen_entry = MessageStatus.objects.filter(message=message, user=recipient).first()
|
|
seen_time = localtime(seen_entry.seen_time).strftime('%m/%d/%Y, %I:%M %p') if seen_entry else "not seen"
|
|
|
|
recipient_status.append({
|
|
'email': recipient.Email1,
|
|
'seen_time': seen_time
|
|
})
|
|
print(recipient_status)
|
|
|
|
return JsonResponse({'status': recipient_status})
|
|
def render_trash_messages(request):
|
|
current_user = request.GET.get('user_id', None)
|
|
current_user_id = get_object_or_404(InternalTeam, user_id=current_user)
|
|
|
|
# Filter trash messages for the current user
|
|
trash_messages = Message.objects.filter(Q(sender=current_user_id),is_trashed=True).order_by('-sent_at')
|
|
print(trash_messages,'trash_messages')
|
|
|
|
# Prepare message data for response
|
|
messages_data = [
|
|
{
|
|
'sender_fullname': message.sender.FullName, # Adjust to your model field
|
|
'sender_id': message.sender_id,
|
|
'recipient_fullname': message.recipient.FullName, # Adjust to your model field
|
|
'recipient_id': message.recipient_id,
|
|
'subject': message.subject,
|
|
'body': message.body,
|
|
'sent_at': localtime(message.sent_at).strftime('%m/%d/%Y, %I:%M:%S %p'), # Adjust as needed
|
|
'message_id': message.message_id,
|
|
'message_type': 'inbox' if message.recipient == current_user_id else 'sent',
|
|
'is_trashed': message.is_trashed
|
|
}
|
|
for message in trash_messages
|
|
]
|
|
return JsonResponse({'trash_messages': messages_data})
|
|
|
|
def send_reply(request):
|
|
if request.method == 'POST':
|
|
current_user = request.GET.get('user_id')
|
|
parent_message_id = request.POST.get('message_id') # The ID of the message being replied to
|
|
|
|
recipients = request.POST.get('toField', '').split(',')
|
|
subject = request.POST.get('subject', '')
|
|
body = request.POST.get('message', '')
|
|
attachment = request.FILES.get('attachment')
|
|
|
|
# Get sender info
|
|
sender = InternalTeam.objects.filter(user_id=current_user).values_list('Email1', flat=True).first()
|
|
sender_id = get_object_or_404(InternalTeam, Email1=sender)
|
|
sender_fullname = sender_id.FullName
|
|
|
|
# Fetch the parent message and get the sender of the parent message
|
|
parent_message = get_object_or_404(Message, message_id=parent_message_id)
|
|
parent_recipients = parent_message.recipient.exclude(user_id=current_user)
|
|
|
|
attachment_url = None
|
|
if attachment:
|
|
myfile = request.FILES['attachment']
|
|
file_name, file_extension = os.path.splitext(myfile.name)
|
|
fs = FileSystemStorage()
|
|
|
|
# Save the file with a unique filename
|
|
filename = fs.save(file_name, attachment)
|
|
attachment_url = fs.url(filename)
|
|
|
|
# Generate a random UUID and use its first 4 digits
|
|
firstname = InternalTeam.objects.filter(user_id=current_user).values_list('FirstName', flat=True).first()
|
|
|
|
message_id = generate_unique_message_id(firstname)
|
|
|
|
recipient_fullnames = []
|
|
recipient_emails = []
|
|
for recipient_email in recipients: # Split by comma
|
|
recipient_id = get_object_or_404(InternalTeam, Email1=recipient_email)
|
|
|
|
recipient_emails.append(recipient_id)
|
|
recipient_fullnames.append(recipient_id.FullName)
|
|
|
|
recipient_details = [{'email': r.Email1, 'fullname': r.FullName} for r in recipient_emails]
|
|
|
|
# Create the reply message to the sender of the parent message
|
|
reply = Message(
|
|
sender=sender_id,
|
|
# recipient=None, # Initially set to None, since we're not assigning directly
|
|
subject=subject,
|
|
body=body,
|
|
is_read=False,
|
|
sender_fullname=sender_fullname,
|
|
recipient_fullname=", ".join(recipient_fullnames),
|
|
message_id=message_id,
|
|
reply_to_id=parent_message,
|
|
attachment=attachment
|
|
)
|
|
reply.save()
|
|
print(reply)
|
|
|
|
# # Use .set() to assign the recipient to the reply
|
|
# all_recipients = list(parent_recipients) + [parent_message.sender]
|
|
# print(all_recipients,'all_recipients')
|
|
reply.recipient.set(recipient_emails)
|
|
|
|
# Return a success response with the reply message ID
|
|
return JsonResponse({'status': 'success','reply_message_id': reply.message_id})
|
|
|
|
else:
|
|
return JsonResponse({'status': 'error', 'message': 'Invalid request method'}, status=400)
|
|
|
|
|
|
def fetch_replies(request, message_id):
|
|
if request.method == 'GET':
|
|
try:
|
|
original_message = Message.objects.get(message_id=message_id)
|
|
|
|
replies = Message.objects.filter(reply_to=original_message).prefetch_related('recipient').order_by('sent_at')
|
|
|
|
def get_attachment_data(reply):
|
|
if not reply.attachment:
|
|
return None
|
|
try:
|
|
fs = FileSystemStorage()
|
|
attachment_url = fs.url(reply.attachment.name)
|
|
file_path = fs.path(reply.attachment.name)
|
|
file_size = os.path.getsize(file_path)
|
|
return {
|
|
'filename': reply.attachment.name.split('/')[-1],
|
|
'url': attachment_url,
|
|
'size': file_size
|
|
}
|
|
except Exception as e:
|
|
print(f"Error retrieving attachment for message {reply.message_id}: {e}")
|
|
return None
|
|
|
|
def get_first_downloaded(message_id):
|
|
file_download = FileDownload.objects.filter(message_id=message_id).first()
|
|
if file_download:
|
|
return localtime(file_download.first_downloaded).strftime('%m/%d/%Y, %I:%M:%S %p')
|
|
return None
|
|
|
|
def get_last_downloaded(message_id):
|
|
file_download = FileDownload.objects.filter(message_id=message_id).first()
|
|
if file_download:
|
|
return localtime(file_download.last_downloaded).strftime('%m/%d/%Y, %I:%M:%S %p')
|
|
return None
|
|
|
|
def serialize_reply(reply):
|
|
return {
|
|
'message_id': reply.message_id,
|
|
'subject': reply.subject,
|
|
'sender_id': reply.sender_id,
|
|
'sender_fullname': reply.sender_fullname,
|
|
'recipient_id': [recipient.Email1 for recipient in reply.recipient.all()],
|
|
'recipient_fullname': reply.recipient_fullname,
|
|
'body': reply.body,
|
|
'sent_at': reply.sent_at.isoformat(),
|
|
'parent_message_id': reply.reply_to_id,
|
|
'attachment': get_attachment_data(reply),
|
|
'first_downloaded': get_first_downloaded(reply.message_id),
|
|
'last_downloaded': get_last_downloaded(reply.message_id),
|
|
'replies': [serialize_reply(r) for r in Message.objects.filter(reply_to=reply).order_by('sent_at')]
|
|
}
|
|
|
|
replies_data = [serialize_reply(reply) for reply in replies]
|
|
|
|
return JsonResponse({'status': 'success', 'replies': replies_data})
|
|
except Message.DoesNotExist:
|
|
return JsonResponse({'status': 'error', 'message': 'Original message not found'}, status=404)
|
|
else:
|
|
return JsonResponse({'status': 'error', 'message': 'Invalid request method'}, status=400)
|
|
|
|
def track_download(request, message_id):
|
|
if request.method == 'GET':
|
|
current_user = request.GET.get('user_id', None)
|
|
current_user_id = get_object_or_404(InternalTeam, user_id=current_user)
|
|
ist_timezone = pytz.timezone('Asia/Kolkata')
|
|
message = get_object_or_404(Message, message_id=message_id)
|
|
|
|
# Prevent the sender from downloading their own message
|
|
if current_user_id == message.sender:
|
|
return JsonResponse({'status': 'error', 'message': 'Sender cannot download the message attachment.'}, status=400)
|
|
|
|
# Ensure the current user is a recipient of the message
|
|
if current_user_id not in message.recipient.all():
|
|
return JsonResponse({'status': 'error', 'message': 'User is not a recipient of this message.'}, status=400)
|
|
|
|
recipient = current_user_id
|
|
|
|
# Track downloads for the original message and its replies
|
|
download_records = []
|
|
for msg in [message] + list(Message.objects.filter(reply_to=message)):
|
|
download, created = FileDownload.objects.get_or_create(
|
|
message=msg,
|
|
user=recipient,
|
|
defaults={
|
|
'first_downloaded': localtime(now(), ist_timezone),
|
|
'last_downloaded': localtime(now(), ist_timezone)
|
|
}
|
|
)
|
|
|
|
# Update the last_downloaded timestamp
|
|
if not created:
|
|
download.last_downloaded = now()
|
|
download.save()
|
|
|
|
download_records.append({
|
|
'message_id': msg.message_id,
|
|
'first_downloaded': localtime(download.first_downloaded, ist_timezone).strftime('%m/%d/%Y, %I:%M:%S %p'),
|
|
'last_downloaded': localtime(download.last_downloaded, ist_timezone).strftime('%m/%d/%Y, %I:%M:%S %p'),
|
|
})
|
|
|
|
return JsonResponse({'status': 'success', 'downloads': download_records})
|
|
else:
|
|
return JsonResponse({'status': 'error', 'message': 'Invalid request method'}, status=400)
|
|
|
|
|
|
def fetch_download_timestamps(request, message_id):
|
|
if request.method == 'GET':
|
|
current_user = request.GET.get('user_id', None)
|
|
current_user_id = get_object_or_404(InternalTeam, user_id=current_user).Email1
|
|
message = get_object_or_404(Message, message_id=message_id)
|
|
ist_timezone = pytz.timezone('Asia/Kolkata')
|
|
|
|
# Separate main message and reply messages
|
|
main_message_downloads = []
|
|
reply_message_downloads = {}
|
|
|
|
# Fetch main message download timestamps
|
|
main_message_records = FileDownload.objects.filter(message=message)
|
|
for record in main_message_records:
|
|
recipient_id = record.user.Email1
|
|
main_message_downloads.append({
|
|
'message_id': message_id,
|
|
'sender_id': message.sender_id,
|
|
'recipient_id': recipient_id,
|
|
'first_downloaded': localtime(record.first_downloaded, ist_timezone).strftime('%m/%d/%Y, %I:%M:%S %p') if record.first_downloaded else None,
|
|
'last_downloaded': localtime(record.last_downloaded, ist_timezone).strftime('%m/%d/%Y, %I:%M:%S %p') if record.last_downloaded else None
|
|
})
|
|
|
|
# Fetch reply message download timestamps
|
|
reply_messages = Message.objects.filter(reply_to=message)
|
|
|
|
for reply in reply_messages:
|
|
download_records = FileDownload.objects.filter(message=reply)
|
|
print(download_records)
|
|
reply_message_downloads[reply.message_id] = []
|
|
|
|
for record in download_records:
|
|
recipient_id = record.user.Email1
|
|
reply_message_downloads[reply.message_id].append({
|
|
'message_id': reply.message_id,
|
|
'sender_id': reply.sender_id,
|
|
'recipient_id': recipient_id,
|
|
'first_downloaded': localtime(record.first_downloaded, ist_timezone).strftime(
|
|
'%m/%d/%Y, %I:%M:%S %p') if record.first_downloaded else None,
|
|
'last_downloaded': localtime(record.last_downloaded, ist_timezone).strftime(
|
|
'%m/%d/%Y, %I:%M:%S %p') if record.last_downloaded else None
|
|
})
|
|
|
|
print(reply_message_downloads)
|
|
|
|
return JsonResponse({
|
|
'main_message_downloads': main_message_downloads,
|
|
'reply_message_downloads': reply_message_downloads,
|
|
'current_user_id': current_user_id
|
|
})
|
|
else:
|
|
return JsonResponse({'status': 'error', 'message': 'Invalid request method'}, status=400)
|
|
|
|
|
|
def get_main_message_id(request,message_id):
|
|
if request.method == 'GET':
|
|
current_message = get_object_or_404(Message, message_id=message_id)
|
|
print(current_message, 'current_message')
|
|
|
|
# Traverse the chain of parent messages to find the main message
|
|
while current_message.reply_to:
|
|
current_message = get_object_or_404(Message, message_id=current_message.reply_to)
|
|
|
|
return JsonResponse({'main_message_id': current_message.message_id})
|
|
else:
|
|
return JsonResponse({'status': 'error', 'message': 'Invalid request method'}, status=400)
|
|
|
|
|
|
def unread_message_count(request):
|
|
if request.method == 'GET':
|
|
user_id = request.GET.get('user_id')
|
|
print(user_id)
|
|
|
|
user = get_object_or_404(InternalTeam, user_id=user_id)
|
|
|
|
# Get all messages that are unread in Message model
|
|
unread = Message.objects.filter(recipient=user, is_read=False).values_list('message_id', flat=True)
|
|
messages_in_status = MessageStatus.objects.filter(message_id__in=unread, user=user).values_list('message_id', flat=True)
|
|
|
|
unread_not_in_status = set(unread) - set(messages_in_status)
|
|
print(unread_not_in_status, 'Unread messages')
|
|
unread_count = len(unread_not_in_status)
|
|
|
|
return JsonResponse({
|
|
'unread_count': unread_count,
|
|
'unread_messages': list(unread_not_in_status) # Convert set to list for JSON response
|
|
})
|
|
return JsonResponse({'status': 'error', 'message': 'Invalid request method'}, status=400)
|