765 lines
24 KiB
Plaintext
765 lines
24 KiB
Plaintext
# communications/api_views.py
|
||
"""API для расширенных функций мессенджера"""
|
||
|
||
from django.contrib.auth.decorators import login_required
|
||
from django.db import models, transaction
|
||
from django.http import JsonResponse
|
||
from django.shortcuts import get_object_or_404
|
||
from django.utils import timezone
|
||
from django.views.decorators.http import require_POST
|
||
|
||
from channels.layers import get_channel_layer
|
||
from asgiref.sync import async_to_sync
|
||
|
||
from .models import (
|
||
Chat,
|
||
ChatMembership,
|
||
ChatUserSettings,
|
||
ForwardedMessage,
|
||
Message,
|
||
MessageAttachment,
|
||
MessageReply,
|
||
)
|
||
|
||
|
||
# ============ CHAT MANAGEMENT ============
|
||
|
||
@login_required
|
||
@require_POST
|
||
def create_chat(request):
|
||
"""
|
||
Создание нового чата
|
||
(group, department, channel, announcement, global)
|
||
"""
|
||
import json
|
||
|
||
# Читаем данные из FormData или JSON
|
||
if request.content_type and 'multipart/form-data' in request.content_type:
|
||
# FormData (с файлами)
|
||
chat_type = request.POST.get('type', 'group')
|
||
name = request.POST.get('name', '').strip()
|
||
description = request.POST.get('description', '').strip()
|
||
department_id = request.POST.get('department_id')
|
||
include_all = request.POST.get('include_all_employees') == 'true'
|
||
is_main = request.POST.get('is_main') == 'true'
|
||
avatar = request.FILES.get('avatar')
|
||
participant_ids = request.POST.getlist('participant_ids')
|
||
else:
|
||
# JSON (без файлов - legacy)
|
||
try:
|
||
data = json.loads(request.body)
|
||
except json.JSONDecodeError:
|
||
return JsonResponse(
|
||
{'ok': False, 'error': 'Invalid JSON'}, status=400
|
||
)
|
||
|
||
chat_type = data.get('type', 'group')
|
||
name = data.get('name', '').strip()
|
||
description = data.get('description', '').strip()
|
||
department_id = data.get('department_id')
|
||
include_all = data.get('include_all_employees', False)
|
||
is_main = data.get('is_main', False)
|
||
avatar = None
|
||
participant_ids = data.get('participant_ids', [])
|
||
|
||
# Валидация типа чата
|
||
valid_types = ['group', 'department', 'channel', 'announcement', 'global']
|
||
if chat_type not in valid_types:
|
||
types_str = ", ".join(valid_types)
|
||
return JsonResponse(
|
||
{
|
||
'ok': False,
|
||
'error': f'Invalid chat type. Must be one of: {types_str}'
|
||
},
|
||
status=400
|
||
)
|
||
|
||
# Валидация для announcement - только 1 на пользователя
|
||
if chat_type == 'announcement':
|
||
existing = Chat.objects.filter(
|
||
type='announcement',
|
||
created_by=request.user
|
||
).first()
|
||
if existing:
|
||
if existing.is_blocked:
|
||
return JsonResponse(
|
||
{
|
||
'ok': False,
|
||
'error': 'Ваш чат объявлений заблокирован администратором'
|
||
},
|
||
status=403
|
||
)
|
||
else:
|
||
return JsonResponse(
|
||
{
|
||
'ok': False,
|
||
'error': 'У вас уже есть чат объявлений',
|
||
'existing_chat_id': existing.id
|
||
},
|
||
status=400
|
||
)
|
||
|
||
# Валидация названия
|
||
if not name and chat_type != 'private':
|
||
# Для announcement генерируем название автоматически
|
||
if chat_type == 'announcement':
|
||
user_name = request.user.get_full_name() or request.user.username
|
||
name = f"Объявления от {user_name}"
|
||
else:
|
||
return JsonResponse(
|
||
{'ok': False, 'error': 'Name is required'}, status=400
|
||
)
|
||
|
||
# Валидация для чата отдела
|
||
if chat_type == 'department':
|
||
if not department_id:
|
||
return JsonResponse(
|
||
{
|
||
'ok': False,
|
||
'error': 'Department is required for department chat'
|
||
},
|
||
status=400
|
||
)
|
||
try:
|
||
from employees.models import Department
|
||
department = Department.objects.get(id=department_id)
|
||
except Department.DoesNotExist:
|
||
return JsonResponse(
|
||
{'ok': False, 'error': 'Department not found'},
|
||
status=400
|
||
)
|
||
else:
|
||
department = None
|
||
|
||
# Валидация для основного чата
|
||
if is_main:
|
||
if chat_type == 'global':
|
||
# Проверяем, нет ли уже основного глобального чата
|
||
if Chat.objects.filter(type='global', is_main=True).exists():
|
||
return JsonResponse(
|
||
{'ok': False, 'error': 'Main global chat already exists'},
|
||
status=400
|
||
)
|
||
elif chat_type == 'department' and department:
|
||
# Проверяем, нет ли уже основного чата для этого отдела
|
||
exists = Chat.objects.filter(
|
||
type='department',
|
||
department=department,
|
||
is_main=True
|
||
).exists()
|
||
if exists:
|
||
return JsonResponse(
|
||
{
|
||
'ok': False,
|
||
'error': 'Main department chat already exists'
|
||
},
|
||
status=400
|
||
)
|
||
|
||
# Создаем чат
|
||
chat = Chat.objects.create(
|
||
type=chat_type,
|
||
name=name,
|
||
description=description,
|
||
created_by=request.user,
|
||
department=department,
|
||
include_all_employees=include_all,
|
||
is_main=is_main,
|
||
can_reply=(chat_type != 'announcement') # Для announcement нельзя
|
||
)
|
||
|
||
# Добавляем аватар если был загружен
|
||
if avatar:
|
||
chat.avatar = avatar
|
||
chat.save() # Создатель - владелец с полными правами
|
||
ChatMembership.objects.create(
|
||
chat=chat,
|
||
user=request.user,
|
||
role='owner',
|
||
can_send_messages=True,
|
||
can_add_members=True,
|
||
can_remove_members=True,
|
||
can_pin_messages=True
|
||
)
|
||
|
||
# Добавляем участников для группового чата
|
||
if chat_type == 'group' and participant_ids:
|
||
from employees.models import Employee
|
||
for emp_id in participant_ids:
|
||
try:
|
||
employee = Employee.objects.get(id=emp_id)
|
||
if employee != request.user: # Создателя уже добавили
|
||
ChatMembership.objects.create(
|
||
chat=chat,
|
||
user=employee,
|
||
role='member',
|
||
can_send_messages=True
|
||
)
|
||
except Employee.DoesNotExist:
|
||
pass
|
||
|
||
# Для чатов с include_all_employees - добавляем всех активных
|
||
if include_all:
|
||
from employees.models import Employee
|
||
all_employees = Employee.objects.filter(is_active=True).exclude(
|
||
id=request.user.id
|
||
)
|
||
for employee in all_employees:
|
||
# Для announcement и channel - обычные участники не могут писать
|
||
if chat_type == 'announcement':
|
||
can_send = False # Только создатель может писать
|
||
elif chat_type == 'channel':
|
||
can_send = False # Только модераторы могут писать
|
||
else:
|
||
can_send = True
|
||
|
||
ChatMembership.objects.get_or_create(
|
||
chat=chat,
|
||
user=employee,
|
||
defaults={
|
||
'role': 'member',
|
||
'can_send_messages': can_send
|
||
}
|
||
)
|
||
|
||
# Для чата отдела - добавляем всех сотрудников отдела
|
||
if chat_type == 'department' and department:
|
||
from employees.models import EmployeeDepartment
|
||
dept_employees = EmployeeDepartment.objects.filter(
|
||
department=department,
|
||
is_active=True
|
||
).select_related('employee')
|
||
|
||
for ed in dept_employees:
|
||
if ed.employee != request.user: # Создателя уже добавили
|
||
ChatMembership.objects.get_or_create(
|
||
chat=chat,
|
||
user=ed.employee,
|
||
defaults={
|
||
'role': 'member',
|
||
'can_send_messages': True
|
||
}
|
||
)
|
||
|
||
return JsonResponse({
|
||
'ok': True,
|
||
'chat_id': chat.id,
|
||
'chat_type': chat.type,
|
||
'name': chat.name
|
||
})
|
||
|
||
|
||
@login_required
|
||
@require_POST
|
||
def block_announcement(request, chat_id):
|
||
"""
|
||
Блокирует announcement чат (только для staff/superuser)
|
||
После блокировки чат скрывается у всех пользователей
|
||
"""
|
||
if not (request.user.is_staff or request.user.is_superuser):
|
||
return JsonResponse(
|
||
{'ok': False, 'error': 'Permission denied'}, status=403
|
||
)
|
||
|
||
chat = get_object_or_404(Chat, pk=chat_id, type='announcement')
|
||
|
||
if chat.is_blocked:
|
||
return JsonResponse(
|
||
{'ok': False, 'error': 'Chat already blocked'}, status=400
|
||
)
|
||
|
||
chat.is_blocked = True
|
||
chat.blocked_at = timezone.now()
|
||
chat.blocked_by = request.user
|
||
chat.save()
|
||
|
||
return JsonResponse({
|
||
'ok': True,
|
||
'message': f'Announcement "{chat.name}" blocked'
|
||
})
|
||
|
||
|
||
@login_required
|
||
@require_POST
|
||
def unblock_announcement(request, chat_id):
|
||
"""
|
||
Разблокирует announcement чат (только для staff/superuser)
|
||
"""
|
||
if not (request.user.is_staff or request.user.is_superuser):
|
||
return JsonResponse(
|
||
{'ok': False, 'error': 'Permission denied'}, status=403
|
||
)
|
||
|
||
chat = get_object_or_404(Chat, pk=chat_id, type='announcement')
|
||
|
||
if not chat.is_blocked:
|
||
return JsonResponse(
|
||
{'ok': False, 'error': 'Chat is not blocked'}, status=400
|
||
)
|
||
|
||
chat.is_blocked = False
|
||
chat.blocked_at = None
|
||
chat.blocked_by = None
|
||
chat.save()
|
||
|
||
return JsonResponse({
|
||
'ok': True,
|
||
'message': f'Announcement "{chat.name}" unblocked'
|
||
})
|
||
|
||
|
||
@login_required
|
||
@require_POST
|
||
def update_chat(request, chat_id):
|
||
"""Обновление названия/описания/аватара чата"""
|
||
chat = get_object_or_404(Chat, pk=chat_id)
|
||
|
||
# Проверка прав (только owner/admin)
|
||
membership = ChatMembership.objects.filter(
|
||
chat=chat,
|
||
user=request.user,
|
||
role__in=['owner', 'admin']
|
||
).first()
|
||
|
||
if not membership:
|
||
return JsonResponse({'ok': False, 'error': 'Forbidden'}, status=403)
|
||
|
||
# Обновление полей
|
||
if 'name' in request.POST:
|
||
chat.name = request.POST['name'].strip()
|
||
if 'description' in request.POST:
|
||
chat.description = request.POST['description'].strip()
|
||
if 'avatar' in request.FILES:
|
||
chat.avatar = request.FILES['avatar']
|
||
|
||
chat.save()
|
||
|
||
return JsonResponse({'ok': True})
|
||
|
||
|
||
# ============ CHAT USER SETTINGS ============
|
||
|
||
@login_required
|
||
@require_POST
|
||
def pin_chat(request, chat_id):
|
||
"""Закрепление/открепление чата"""
|
||
chat = get_object_or_404(Chat, pk=chat_id)
|
||
is_pinned = request.POST.get('pinned', 'true').lower() == 'true'
|
||
|
||
settings, created = ChatUserSettings.objects.get_or_create(
|
||
chat=chat,
|
||
user=request.user
|
||
)
|
||
|
||
settings.is_pinned = is_pinned
|
||
if is_pinned:
|
||
settings.pinned_at = timezone.now()
|
||
# Определяем порядок
|
||
max_order = ChatUserSettings.objects.filter(
|
||
user=request.user,
|
||
is_pinned=True
|
||
).aggregate(max_order=models.Max('pin_order'))['max_order'] or 0
|
||
settings.pin_order = max_order + 1
|
||
else:
|
||
settings.pinned_at = None
|
||
settings.pin_order = 0
|
||
|
||
settings.save()
|
||
|
||
return JsonResponse({'ok': True, 'pinned': is_pinned})
|
||
|
||
|
||
@login_required
|
||
@require_POST
|
||
def set_chat_notifications(request, chat_id):
|
||
"""Включение/выключение уведомлений"""
|
||
chat = get_object_or_404(Chat, pk=chat_id)
|
||
enabled = request.POST.get('enabled', 'true').lower() == 'true'
|
||
|
||
settings, created = ChatUserSettings.objects.get_or_create(
|
||
chat=chat,
|
||
user=request.user
|
||
)
|
||
settings.notifications_enabled = enabled
|
||
settings.save()
|
||
|
||
return JsonResponse({'ok': True, 'enabled': enabled})
|
||
|
||
|
||
# ============ MESSAGE ACTIONS ============
|
||
|
||
@login_required
|
||
@require_POST
|
||
def edit_message(request, message_id):
|
||
"""Редактирование сообщения"""
|
||
message = get_object_or_404(Message, pk=message_id)
|
||
|
||
if message.author != request.user:
|
||
return JsonResponse({'ok': False, 'error': 'Forbidden'}, status=403)
|
||
|
||
new_content = request.POST.get('content', '').strip()
|
||
if not new_content:
|
||
return JsonResponse({'ok': False, 'error': 'Empty content'}, status=400)
|
||
|
||
# Сохраняем историю
|
||
if not message.is_edited:
|
||
message.edit_history = []
|
||
|
||
message.edit_history.append({
|
||
'timestamp': timezone.now().isoformat(),
|
||
'old_content': message.content
|
||
})
|
||
|
||
message.content = new_content
|
||
message.is_edited = True
|
||
message.edited_at = timezone.now()
|
||
message.save()
|
||
|
||
return JsonResponse({'ok': True, 'edited_at': message.edited_at.isoformat()})
|
||
|
||
|
||
@login_required
|
||
@require_POST
|
||
def delete_message(request, message_id):
|
||
"""Удаление сообщения"""
|
||
import logging
|
||
logger = logging.getLogger(__name__)
|
||
|
||
logger.info(
|
||
"[DELETE_MESSAGE] API called: message_id=%s, user=%s",
|
||
message_id, request.user.username
|
||
)
|
||
|
||
message = get_object_or_404(Message, pk=message_id)
|
||
logger.info(
|
||
"[DELETE_MESSAGE] Message found: chat_id=%s, author=%s",
|
||
message.chat_id, message.author.username
|
||
)
|
||
|
||
# Проверка: автор или модератор/админ чата
|
||
can_delete = False
|
||
if message.author == request.user:
|
||
can_delete = True
|
||
logger.info("[DELETE_MESSAGE] User is author, can delete")
|
||
else:
|
||
membership = ChatMembership.objects.filter(
|
||
chat=message.chat,
|
||
user=request.user,
|
||
role__in=['owner', 'admin', 'moderator']
|
||
).first()
|
||
if membership:
|
||
can_delete = True
|
||
logger.info(
|
||
"[DELETE_MESSAGE] User has moderator role: %s",
|
||
membership.role
|
||
)
|
||
|
||
if not can_delete:
|
||
logger.warning(
|
||
"[DELETE_MESSAGE] Permission denied for user %s",
|
||
request.user.username
|
||
)
|
||
return JsonResponse({'ok': False, 'error': 'Forbidden'}, status=403)
|
||
|
||
logger.info("[DELETE_MESSAGE] Marking message as deleted")
|
||
message.is_deleted = True
|
||
message.deleted_at = timezone.now()
|
||
message.deleted_by = request.user
|
||
message.save()
|
||
logger.info(
|
||
"[DELETE_MESSAGE] Message deleted successfully: %s", message_id
|
||
)
|
||
|
||
# Отправляем WebSocket событие всем участникам чата
|
||
logger.info(
|
||
"[DELETE_MESSAGE] Sending WebSocket event to chat group: chat_%s",
|
||
message.chat_id
|
||
)
|
||
channel_layer = get_channel_layer()
|
||
async_to_sync(channel_layer.group_send)(
|
||
f"chat_{message.chat_id}",
|
||
{
|
||
"type": "chat.message_deleted",
|
||
"chat_id": message.chat_id,
|
||
"message_id": message_id
|
||
}
|
||
)
|
||
logger.info(
|
||
"[DELETE_MESSAGE] WebSocket event sent for message_id=%s", message_id
|
||
)
|
||
|
||
return JsonResponse({'ok': True})
|
||
|
||
|
||
@login_required
|
||
@require_POST
|
||
def pin_message(request, message_id):
|
||
"""Закрепление сообщения в чате"""
|
||
message = get_object_or_404(Message, pk=message_id)
|
||
|
||
# Проверка прав
|
||
membership = ChatMembership.objects.filter(
|
||
chat=message.chat,
|
||
user=request.user,
|
||
can_pin_messages=True
|
||
).first()
|
||
|
||
if not membership:
|
||
return JsonResponse({'ok': False, 'error': 'Forbidden'}, status=403)
|
||
|
||
is_pinned = request.POST.get('pinned', 'true').lower() == 'true'
|
||
|
||
message.is_pinned = is_pinned
|
||
if is_pinned:
|
||
message.pinned_by = request.user
|
||
message.pinned_at = timezone.now()
|
||
else:
|
||
message.pinned_by = None
|
||
message.pinned_at = None
|
||
|
||
message.save()
|
||
|
||
return JsonResponse({'ok': True, 'pinned': is_pinned})
|
||
|
||
|
||
# ============ ATTACHMENTS ============
|
||
# Примечание: endpoint для загрузки сообщений с файлами
|
||
# перенесён в api/v1/communications/views.py
|
||
|
||
@login_required
|
||
@require_POST
|
||
def upload_attachment(request):
|
||
"""Загрузка вложения к существующему сообщению"""
|
||
if 'file' not in request.FILES:
|
||
return JsonResponse({'ok': False, 'error': 'No file'}, status=400)
|
||
|
||
message_id = request.POST.get('message_id')
|
||
if not message_id:
|
||
return JsonResponse(
|
||
{'ok': False, 'error': 'message_id required'},
|
||
status=400
|
||
)
|
||
|
||
message = get_object_or_404(Message, pk=message_id)
|
||
|
||
if message.author != request.user:
|
||
return JsonResponse({'ok': False, 'error': 'Forbidden'}, status=403)
|
||
|
||
uploaded_file = request.FILES['file']
|
||
|
||
# Определение типа файла
|
||
mime_type = uploaded_file.content_type or ''
|
||
if mime_type.startswith('image/'):
|
||
file_type = 'image'
|
||
elif mime_type.startswith('video/'):
|
||
file_type = 'video'
|
||
elif mime_type.startswith('audio/'):
|
||
file_type = 'audio'
|
||
else:
|
||
file_type = 'file'
|
||
|
||
attachment = MessageAttachment.objects.create(
|
||
message=message,
|
||
file=uploaded_file,
|
||
file_type=file_type,
|
||
file_name=uploaded_file.name,
|
||
file_size=uploaded_file.size,
|
||
mime_type=mime_type
|
||
)
|
||
|
||
message.has_attachments = True
|
||
message.save()
|
||
|
||
return JsonResponse({
|
||
'ok': True,
|
||
'attachment_id': attachment.id,
|
||
'file_name': attachment.file_name,
|
||
'file_type': attachment.file_type,
|
||
'file_url': attachment.file.url
|
||
})
|
||
|
||
|
||
# ============ FORWARDING ============
|
||
|
||
@login_required
|
||
@require_POST
|
||
def forward_message(request, message_id):
|
||
"""Пересылка сообщения в другой чат"""
|
||
original = get_object_or_404(Message, pk=message_id)
|
||
target_chat_id = request.POST.get('target_chat_id')
|
||
|
||
if not target_chat_id:
|
||
return JsonResponse({'ok': False, 'error': 'target_chat_id required'}, status=400)
|
||
|
||
target_chat = get_object_or_404(Chat, pk=target_chat_id)
|
||
|
||
# Проверка доступа к целевому чату
|
||
membership = ChatMembership.objects.filter(
|
||
chat=target_chat,
|
||
user=request.user,
|
||
can_send_messages=True
|
||
).first()
|
||
|
||
if not membership:
|
||
return JsonResponse({'ok': False, 'error': 'Cannot send to this chat'}, status=403)
|
||
|
||
with transaction.atomic():
|
||
# Создаем новое сообщение
|
||
forwarded = Message.objects.create(
|
||
chat=target_chat,
|
||
author=request.user,
|
||
content=original.content,
|
||
is_forwarded=True
|
||
)
|
||
|
||
# Определяем оригинальное сообщение в цепочке
|
||
if hasattr(original, 'forward_info'):
|
||
original_message = original.forward_info.original_message
|
||
forward_count = original.forward_info.forward_count + 1
|
||
else:
|
||
original_message = original
|
||
forward_count = 1
|
||
|
||
# Создаем информацию о пересылке
|
||
ForwardedMessage.objects.create(
|
||
message=forwarded,
|
||
original_message=original_message,
|
||
immediate_source=original,
|
||
original_chat=original.chat,
|
||
original_author=original.author,
|
||
forwarded_by=request.user,
|
||
forward_count=forward_count,
|
||
preserved_content=original.content,
|
||
preserved_author_name=original.author.get_full_name()
|
||
)
|
||
|
||
return JsonResponse({'ok': True, 'new_message_id': forwarded.id})
|
||
|
||
|
||
# ============ REPLIES ============
|
||
|
||
@login_required
|
||
@require_POST
|
||
def reply_to_message(request, message_id):
|
||
"""Ответ на сообщение"""
|
||
replied_to = get_object_or_404(Message, pk=message_id)
|
||
content = request.POST.get('content', '').strip()
|
||
reply_type = request.POST.get('reply_type', 'inline')
|
||
|
||
if not content:
|
||
return JsonResponse({'ok': False, 'error': 'Content required'}, status=400)
|
||
|
||
# Создаем сообщение-ответ
|
||
reply = Message.objects.create(
|
||
chat=replied_to.chat,
|
||
author=request.user,
|
||
content=content,
|
||
reply_to=replied_to
|
||
)
|
||
|
||
# Создаем расширенную информацию об ответе
|
||
MessageReply.objects.create(
|
||
message=reply,
|
||
replied_to=replied_to,
|
||
is_cross_chat_reply=False,
|
||
preserved_text=replied_to.content[:200],
|
||
preserved_author_name=replied_to.author.get_full_name(),
|
||
reply_type=reply_type
|
||
)
|
||
|
||
# Если это тред, обновляем счетчик
|
||
if reply_type == 'thread':
|
||
if replied_to.thread_root:
|
||
root = replied_to.thread_root
|
||
else:
|
||
root = replied_to
|
||
|
||
reply.thread_root = root
|
||
reply.save()
|
||
|
||
root.thread_reply_count += 1
|
||
root.save()
|
||
|
||
return JsonResponse({
|
||
'ok': True,
|
||
'reply_id': reply.id,
|
||
'replied_to_id': replied_to.id
|
||
})
|
||
|
||
|
||
# ============ CHAT MEMBERSHIP ============
|
||
|
||
@login_required
|
||
@require_POST
|
||
def add_member(request, chat_id):
|
||
"""Добавление участника в чат"""
|
||
chat = get_object_or_404(Chat, pk=chat_id)
|
||
user_id = request.POST.get('user_id')
|
||
|
||
if not user_id:
|
||
return JsonResponse({'ok': False, 'error': 'user_id required'}, status=400)
|
||
|
||
# Проверка прав
|
||
membership = ChatMembership.objects.filter(
|
||
chat=chat,
|
||
user=request.user,
|
||
can_add_members=True
|
||
).first()
|
||
|
||
if not membership:
|
||
return JsonResponse({'ok': False, 'error': 'Forbidden'}, status=403)
|
||
|
||
from employees.models import Employee
|
||
new_user = get_object_or_404(Employee, pk=user_id)
|
||
|
||
# Создаем или активируем участие
|
||
new_membership, created = ChatMembership.objects.get_or_create(
|
||
chat=chat,
|
||
user=new_user,
|
||
defaults={
|
||
'role': 'member',
|
||
'invited_by': request.user,
|
||
'can_send_messages': True
|
||
}
|
||
)
|
||
|
||
if not created and not new_membership.is_active:
|
||
new_membership.is_active = True
|
||
new_membership.left_at = None
|
||
new_membership.save()
|
||
|
||
return JsonResponse({'ok': True, 'created': created})
|
||
|
||
|
||
@login_required
|
||
@require_POST
|
||
def remove_member(request, chat_id):
|
||
"""Удаление участника из чата"""
|
||
chat = get_object_or_404(Chat, pk=chat_id)
|
||
user_id = request.POST.get('user_id')
|
||
|
||
if not user_id:
|
||
return JsonResponse({'ok': False, 'error': 'user_id required'}, status=400)
|
||
|
||
# Проверка прав
|
||
membership = ChatMembership.objects.filter(
|
||
chat=chat,
|
||
user=request.user,
|
||
can_remove_members=True
|
||
).first()
|
||
|
||
if not membership:
|
||
return JsonResponse({'ok': False, 'error': 'Forbidden'}, status=403)
|
||
|
||
target_membership = ChatMembership.objects.filter(
|
||
chat=chat,
|
||
user_id=user_id
|
||
).first()
|
||
|
||
if target_membership:
|
||
target_membership.is_active = False
|
||
target_membership.left_at = timezone.now()
|
||
target_membership.save()
|
||
|
||
return JsonResponse({'ok': True})
|