376 lines
14 KiB
Python
376 lines
14 KiB
Python
from django.contrib.auth import get_user_model
|
|
from django.db.models import Q
|
|
from django.shortcuts import get_object_or_404
|
|
from uuid import UUID
|
|
from rest_framework import status
|
|
from rest_framework.permissions import IsAuthenticated
|
|
from rest_framework.response import Response
|
|
from rest_framework.views import APIView
|
|
|
|
from .models import CallSession, EmployeeAttendance, Meeting, MeetingParticipant, TrainingRecord
|
|
from .permissions import IsMeetingModerator, IsTrainer
|
|
from .serializers import (
|
|
CallEventSerializer,
|
|
CallModerationRequestSerializer,
|
|
CallParticipantSerializer,
|
|
CallSessionSerializer,
|
|
EmployeeAttendanceSerializer,
|
|
MeetingAttendanceRequestSerializer,
|
|
MeetingParticipantSerializer,
|
|
MeetingSerializer,
|
|
SignoffRequestSerializer,
|
|
TrainerSignoffSerializer,
|
|
TrainingRecordSerializer,
|
|
)
|
|
from .services import (
|
|
CallSessionError,
|
|
InvalidTransitionError,
|
|
apply_moderation_action,
|
|
end_call_session,
|
|
get_or_create_call_session,
|
|
mark_in_progress,
|
|
mark_online_passed,
|
|
record_meeting_attendance,
|
|
submit_trainer_signoff,
|
|
toggle_screen_share,
|
|
)
|
|
|
|
|
|
class TrainingRecordDetailView(APIView):
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def get(self, request, record_id):
|
|
record = get_object_or_404(
|
|
TrainingRecord,
|
|
pk=record_id,
|
|
enrollment__user=request.user,
|
|
)
|
|
return Response(TrainingRecordSerializer(record).data)
|
|
|
|
|
|
class MarkInProgressView(APIView):
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def post(self, request, record_id):
|
|
record = get_object_or_404(
|
|
TrainingRecord, pk=record_id, enrollment__user=request.user
|
|
)
|
|
try:
|
|
record = mark_in_progress(record)
|
|
except InvalidTransitionError as exc:
|
|
return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)
|
|
return Response(TrainingRecordSerializer(record).data)
|
|
|
|
|
|
class MarkOnlinePassedView(APIView):
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def post(self, request, record_id):
|
|
record = get_object_or_404(
|
|
TrainingRecord, pk=record_id, enrollment__user=request.user
|
|
)
|
|
try:
|
|
record = mark_online_passed(record)
|
|
except InvalidTransitionError as exc:
|
|
return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)
|
|
return Response(TrainingRecordSerializer(record).data)
|
|
|
|
|
|
class TrainerSignoffView(APIView):
|
|
permission_classes = [IsAuthenticated, IsTrainer]
|
|
|
|
def post(self, request, record_id):
|
|
record = get_object_or_404(TrainingRecord, pk=record_id)
|
|
serializer = SignoffRequestSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
try:
|
|
signoff = submit_trainer_signoff(
|
|
record,
|
|
trainer=request.user,
|
|
decision=serializer.validated_data["decision"],
|
|
notes=serializer.validated_data["notes"],
|
|
)
|
|
except InvalidTransitionError as exc:
|
|
return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)
|
|
|
|
return Response(TrainerSignoffSerializer(signoff).data, status=status.HTTP_201_CREATED)
|
|
|
|
|
|
class PendingSignoffListView(APIView):
|
|
permission_classes = [IsAuthenticated, IsTrainer]
|
|
|
|
def get(self, request):
|
|
from .models import CompletionStatus
|
|
records = TrainingRecord.objects.filter(
|
|
status__in=[CompletionStatus.PENDING_SIGNOFF, CompletionStatus.IN_PROGRESS],
|
|
).select_related("enrollment__user", "enrollment__course")
|
|
return Response(TrainingRecordSerializer(records, many=True).data)
|
|
|
|
|
|
class MeetingListCreateView(APIView):
|
|
permission_classes = [IsAuthenticated, IsTrainer]
|
|
|
|
def get(self, request):
|
|
return Response(MeetingSerializer(Meeting.objects.all(), many=True).data)
|
|
|
|
def post(self, request):
|
|
serializer = MeetingSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
meeting = serializer.save()
|
|
return Response(MeetingSerializer(meeting).data, status=status.HTTP_201_CREATED)
|
|
|
|
|
|
class MeetingParticipantsCreateView(APIView):
|
|
permission_classes = [IsAuthenticated, IsTrainer]
|
|
|
|
def post(self, request, meeting_id):
|
|
meeting = get_object_or_404(Meeting, pk=meeting_id)
|
|
user_identifier = (request.data.get("user") or "").strip()
|
|
if not user_identifier:
|
|
return Response({"detail": "user is required."}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
user_model = get_user_model()
|
|
identifier_filters = Q(email__iexact=user_identifier) | Q(oidc_sub=user_identifier)
|
|
try:
|
|
identifier_filters = Q(pk=UUID(user_identifier)) | identifier_filters
|
|
except ValueError:
|
|
pass
|
|
|
|
participant_user = user_model.objects.filter(identifier_filters).first()
|
|
if participant_user is None:
|
|
return Response(
|
|
{"detail": "User not found. Use user UUID, email, or external user ID."},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
serializer = MeetingParticipantSerializer(data={
|
|
"meeting": str(meeting.id),
|
|
"user": str(participant_user.id),
|
|
})
|
|
serializer.is_valid(raise_exception=True)
|
|
participant = MeetingParticipant.objects.create(
|
|
meeting=meeting,
|
|
user_id=participant_user.id,
|
|
)
|
|
return Response(MeetingParticipantSerializer(participant).data, status=status.HTTP_201_CREATED)
|
|
|
|
|
|
class MeetingAttendanceView(APIView):
|
|
permission_classes = [IsAuthenticated, IsTrainer]
|
|
|
|
def post(self, request, meeting_id):
|
|
meeting = get_object_or_404(Meeting, pk=meeting_id)
|
|
serializer = MeetingAttendanceRequestSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
participant = get_object_or_404(
|
|
MeetingParticipant,
|
|
meeting=meeting,
|
|
user_id=serializer.validated_data["user_id"],
|
|
)
|
|
|
|
participant = record_meeting_attendance(
|
|
meeting,
|
|
user_id=participant.user_id,
|
|
status_value=serializer.validated_data["status"],
|
|
actor=request.user,
|
|
)
|
|
return Response(MeetingParticipantSerializer(participant).data)
|
|
|
|
|
|
class MeetingDetailView(APIView):
|
|
permission_classes = [IsAuthenticated, IsTrainer]
|
|
|
|
def get(self, request, meeting_id):
|
|
meeting = get_object_or_404(Meeting, pk=meeting_id)
|
|
participants = meeting.participants.select_related("user", "attendance_recorded_by")
|
|
data = MeetingSerializer(meeting).data
|
|
data["participants"] = MeetingParticipantSerializer(participants, many=True).data
|
|
return Response(data)
|
|
|
|
|
|
class MeetingCallSessionView(APIView):
|
|
"""
|
|
GET /meetings/{id}/call/ — get current call session state (participants + trainer)
|
|
POST /meetings/{id}/call/ — start or resume a call session (trainer only)
|
|
DELETE /meetings/{id}/call/ — end a call session (trainer only); sends session_ended to all WS clients
|
|
"""
|
|
|
|
def get_permissions(self):
|
|
if self.request.method in ("POST", "DELETE"):
|
|
return [IsAuthenticated(), IsMeetingModerator()]
|
|
return [IsAuthenticated()]
|
|
|
|
def get(self, request, meeting_id):
|
|
meeting = get_object_or_404(Meeting, pk=meeting_id)
|
|
try:
|
|
session = meeting.call_session
|
|
except CallSession.DoesNotExist:
|
|
return Response({"detail": "No call session exists for this meeting."}, status=status.HTTP_404_NOT_FOUND)
|
|
return Response(CallSessionSerializer(session).data)
|
|
|
|
def post(self, request, meeting_id):
|
|
meeting = get_object_or_404(Meeting, pk=meeting_id)
|
|
try:
|
|
session = get_or_create_call_session(meeting, actor=request.user)
|
|
except CallSessionError as exc:
|
|
return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)
|
|
return Response(CallSessionSerializer(session).data, status=status.HTTP_201_CREATED)
|
|
|
|
def delete(self, request, meeting_id):
|
|
meeting = get_object_or_404(Meeting, pk=meeting_id)
|
|
try:
|
|
session = meeting.call_session
|
|
except CallSession.DoesNotExist:
|
|
return Response({"detail": "No call session found."}, status=status.HTTP_404_NOT_FOUND)
|
|
try:
|
|
session = end_call_session(session, actor=request.user)
|
|
except CallSessionError as exc:
|
|
return Response({"detail": str(exc)}, status=status.HTTP_409_CONFLICT)
|
|
|
|
_broadcast_session_ended(str(meeting.id))
|
|
return Response(CallSessionSerializer(session).data)
|
|
|
|
|
|
class MeetingCallModerationView(APIView):
|
|
"""
|
|
POST /meetings/{id}/call/moderate/
|
|
Body: {"action": "mute"|"unmute"|"kick", "user_id": "<uuid>"}
|
|
Moderator-only (meeting:moderate capability). Writes audit event + broadcasts WS event.
|
|
"""
|
|
|
|
permission_classes = [IsAuthenticated, IsMeetingModerator]
|
|
|
|
def post(self, request, meeting_id):
|
|
meeting = get_object_or_404(Meeting, pk=meeting_id)
|
|
try:
|
|
session = meeting.call_session
|
|
except CallSession.DoesNotExist:
|
|
return Response({"detail": "No active call session."}, status=status.HTTP_404_NOT_FOUND)
|
|
|
|
serializer = CallModerationRequestSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
action = serializer.validated_data["action"]
|
|
target_user_id = serializer.validated_data["user_id"]
|
|
|
|
try:
|
|
apply_moderation_action(session, action, target_user_id, actor=request.user)
|
|
except CallSessionError as exc:
|
|
return Response({"detail": str(exc)}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
_broadcast_moderation(str(meeting.id), action, str(target_user_id), str(request.user.id))
|
|
return Response({"detail": f"{action} applied."})
|
|
|
|
|
|
class MeetingCallScreenShareView(APIView):
|
|
"""
|
|
POST /meetings/{id}/call/screen-share/
|
|
Body: {"action": "start"|"stop"}
|
|
Moderator-only. Only users with meeting:moderate can start/stop screen sharing.
|
|
"""
|
|
|
|
permission_classes = [IsAuthenticated, IsMeetingModerator]
|
|
|
|
def post(self, request, meeting_id):
|
|
meeting = get_object_or_404(Meeting, pk=meeting_id)
|
|
try:
|
|
session = meeting.call_session
|
|
except CallSession.DoesNotExist:
|
|
return Response({"detail": "No active call session."}, status=status.HTTP_404_NOT_FOUND)
|
|
|
|
action = request.data.get("action")
|
|
if action not in ("start", "stop"):
|
|
return Response({"detail": "action must be 'start' or 'stop'."}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
try:
|
|
cp = toggle_screen_share(session, actor=request.user, start=(action == "start"))
|
|
except CallSessionError as exc:
|
|
return Response({"detail": str(exc)}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
_broadcast_screen_share(str(meeting.id), action, str(request.user.id))
|
|
return Response(CallParticipantSerializer(cp).data)
|
|
|
|
|
|
class MeetingCallEventsView(APIView):
|
|
"""
|
|
GET /meetings/{id}/call/events/ — audit log for moderation/session events (moderator only)
|
|
"""
|
|
|
|
permission_classes = [IsAuthenticated, IsMeetingModerator]
|
|
|
|
def get(self, request, meeting_id):
|
|
meeting = get_object_or_404(Meeting, pk=meeting_id)
|
|
try:
|
|
session = meeting.call_session
|
|
except CallSession.DoesNotExist:
|
|
return Response({"detail": "No call session found."}, status=status.HTTP_404_NOT_FOUND)
|
|
events = session.events.select_related("actor", "target_user")
|
|
return Response(CallEventSerializer(events, many=True).data)
|
|
|
|
|
|
def _broadcast_session_ended(meeting_id: str):
|
|
from asgiref.sync import async_to_sync
|
|
from channels.layers import get_channel_layer
|
|
|
|
channel_layer = get_channel_layer()
|
|
if channel_layer is None:
|
|
return
|
|
group = f"meeting_call_{meeting_id}"
|
|
async_to_sync(channel_layer.group_send)(group, {"type": "call.session_ended"})
|
|
|
|
|
|
def _broadcast_moderation(meeting_id: str, action: str, user_id: str, by: str):
|
|
from asgiref.sync import async_to_sync
|
|
from channels.layers import get_channel_layer
|
|
|
|
channel_layer = get_channel_layer()
|
|
if channel_layer is None:
|
|
return
|
|
group = f"meeting_call_{meeting_id}"
|
|
|
|
if action == "kick":
|
|
msg = {"type": "call.kicked", "user_id": user_id, "kicked_by": by}
|
|
elif action == "mute":
|
|
msg = {"type": "call.muted", "user_id": user_id, "by": by}
|
|
else:
|
|
msg = {"type": "call.unmuted", "user_id": user_id, "by": by}
|
|
|
|
async_to_sync(channel_layer.group_send)(group, msg)
|
|
|
|
|
|
def _broadcast_screen_share(meeting_id: str, action: str, by: str):
|
|
from asgiref.sync import async_to_sync
|
|
from channels.layers import get_channel_layer
|
|
|
|
channel_layer = get_channel_layer()
|
|
if channel_layer is None:
|
|
return
|
|
group = f"meeting_call_{meeting_id}"
|
|
msg_type = "call.screen_share_started" if action == "start" else "call.screen_share_stopped"
|
|
async_to_sync(channel_layer.group_send)(group, {"type": msg_type, "by": by})
|
|
|
|
|
|
class EmployeeAttendanceListView(APIView):
|
|
"""
|
|
GET /training/attendance/ — own attendance history
|
|
GET /training/attendance/?user=id — another user's history (trainer/manager/admin only)
|
|
"""
|
|
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def get(self, request):
|
|
target_user_id = request.query_params.get("user")
|
|
if target_user_id and target_user_id != str(request.user.id):
|
|
from accounts.services import get_effective_capabilities
|
|
caps = get_effective_capabilities(request.user)
|
|
if not any(c in caps for c in ("progress:view_all", "progress:view_team", "users:manage")):
|
|
return Response({"detail": "Permission denied."}, status=403)
|
|
qs = EmployeeAttendance.objects.filter(user_id=target_user_id)
|
|
else:
|
|
qs = EmployeeAttendance.objects.filter(user=request.user)
|
|
|
|
qs = qs.select_related("meeting", "updated_by").order_by("-attendance_date")
|
|
return Response(EmployeeAttendanceSerializer(qs, many=True).data)
|