factory/apps/ecm/views.py

from threading import Thread
from apps.ecm.filters import EventFilterSet
from apps.ecm.models import AlgoChannel, Event, EventCate, Eventdo, Remind, NotifySetting
from apps.ecm.serializers import (AlgoChannelCreateSerializer, AlgoChannelCreatesSerializer, AlgoChannelSerializer, EventAggSerializer, EventCateCreateUpdateSerializer, EventCateListSerializer, EventCateUpdateSerializer, EventHandleSerializer,
                                  EventSerializer, RemindSerializer, NotifySettingsSerializer)
from apps.ecm.service import update_remind_read
from apps.utils.viewsets import CustomGenericViewSet, CustomModelViewSet
from rest_framework.mixins import UpdateModelMixin, ListModelMixin, RetrieveModelMixin, CreateModelMixin, DestroyModelMixin
from django.db import transaction
from rest_framework.decorators import action
from rest_framework import serializers
from django.utils import timezone
from rest_framework.response import Response
from rest_framework.exceptions import PermissionDenied
from apps.utils.snowflake import idWorker
from django.db.models import Count, F


# Create your views here.
class EventCateViewSet(CreateModelMixin, UpdateModelMixin, ListModelMixin, CustomGenericViewSet):
    perms_map = {'get': '*', 'put': 'event_cate:update', 'post': 'event_cate:create'}
    queryset = EventCate.objects.all()
    list_serializer_class = EventCateListSerializer
    create_serializer_class = EventCateCreateUpdateSerializer
    update_serializer_class = EventCateCreateUpdateSerializer
    serializer_class = EventCateListSerializer
    filterset_fields = ['self_algo']
    ordering = ['-priority', 'create_time']


class AlgoChannelViewSet(CreateModelMixin, DestroyModelMixin, ListModelMixin, CustomGenericViewSet):
    perms_map = {'get': '*', 'post': 'event_cate:update', 'delete': 'event_cate:create'}
    queryset = AlgoChannel.objects.all()
    create_serializer_class = AlgoChannelCreateSerializer
    serializer_class = AlgoChannelSerializer
    filterset_fields = ['algo']

    @transaction.atomic
    @action(methods=['post'], detail=False, perms_map={'post': 'event_cate:update'},
            serializer_class=AlgoChannelCreatesSerializer)
    def creates(self, request, pk=None):
        """批量添加摄像头

        批量添加摄像头
        """
        serializer = AlgoChannelCreatesSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        vdata = serializer.validated_data
        for i in vdata['vchannels']:
            AlgoChannel.objects.get_or_create(algo=vdata['algo'], vchannel=i,
                                              defaults={
                "algo": vdata['algo'],
                "vchannel": i
            })
        return Response()


class NotifySettingViewSet(CustomModelViewSet):
    queryset = NotifySetting.objects.all()
    serializer_class = NotifySettingsSerializer
    filterset_fields = ['event_cate', 'obj_cate', 'post', 'user']


class EventViewSet(ListModelMixin, RetrieveModelMixin, CustomGenericViewSet):
    perms_map = {'get': '*'}
    queryset = Event.objects.all()
    serializer_class = EventSerializer
    select_related_fields = ['area', 'employee', 'handle_user']
    prefetch_related_fields = ['cates']
    filterset_class = EventFilterSet

    @transaction.atomic
    @action(methods=['post'], detail=True, perms_map={'post': '*'},
            serializer_class=EventHandleSerializer)
    def handle(self, request, pk=None):
        """处理事件

        处理事件
        """
        obj = self.get_object()
        # 判断当前用户有无处理权限
        if (not Remind.objects.filter(event=obj, recipient=request.user, can_handle=True).exists()) and (not request.user.is_superuser):
            raise PermissionDenied('您无权处理该事件')
        data = request.data
        obj.mark = data.get('mark')
        obj.handle_desc = data.get('handle_desc', '')
        obj.handle_user = request.user
        obj.handle_time = timezone.now()
        obj.save()
        Thread(target=update_remind_read, args=(obj, request.user), daemon=True).start()
        return Response()

    def retrieve(self, request, *args, **kwargs):
        obj = self.get_object()
        Thread(target=update_remind_read, args=(obj, request.user), daemon=True).start()
        return super().retrieve(request, *args, **kwargs)

    @transaction.atomic
    @action(methods=['post'], detail=False, perms_map={'post': '*'},
            serializer_class=EventAggSerializer)
    def cate_agg(self, request, pk=None):
        """按事件分类聚合

        按事件分类聚合
        """
        slr = EventAggSerializer(data=request.data)
        slr.is_valid(raise_exception=True)
        vdata = slr.validated_data
        ret = {}
        queryset = Eventdo.objects.all()
        if vdata.get('start_create', None):
            queryset = queryset.filter(event__create_time__gte=vdata['start_create'])
        if vdata.get('end_create', None):
            queryset = queryset.filter(event__create_time__lte=vdata['end_create'])
        if vdata.get('is_handled', None):
            if vdata['is_handled']:
                queryset = queryset.exclude(event__handle_user=None)
            else:
                queryset = queryset.filter(event__handle_user=None)
        ret['total_count'] = queryset.count()
        if vdata.get('completed', True):
            ret['details'] = list(EventCate.objects.order_by('-priority', 'create_time').annotate(cate=F('id'), cate__name=F('name')).values('cate', 'cate__name'))
            for i in ret['details']:
                i['count'] = queryset.filter(cate__id=i['cate']).count()
        else:
            ret['details'] = list(queryset.order_by('-cate__priority', 'cate__create_time').values(
                'cate', 'cate__name').annotate(count=Count('cate')))
        return Response(ret)


class RemindViewSet(ListModelMixin, CustomGenericViewSet):
    perms_map = {'get': '*'}
    queryset = Remind.objects.all()
    serializer_class = RemindSerializer
    select_related_fields = ['recipient', 'event']
    prefetch_related_fields = ['event__cates']
    filterset_fields = ['event', 'event__cates', 'is_read']

    @action(methods=['get'], detail=False, perms_map={'get': '*'})
    def my(self, request, *args, **kwargs):
        """推送给我的

        推送给我的
        """
        user = self.request.user
        queryset = self.filter_queryset(self.get_queryset().filter(recipient=user))

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)


# class MyRemindViewSet(ListModelMixin, CustomGenericViewSet):
#     perms_map = {'get': '*'}
#     serializer_class = RemindSerializer
#     select_related_fields = ['recipient', 'event']
#     prefetch_related_fields = ['event__cates']

#     def get_queryset(self):
#         return Remind.objects.filter(recipient=self.request.user)

#     @action(methods=['post'], detail=True, perms_map={'post': '*'})
#     def label_read(self, request, *args, **kwargs):
#         """标记已读

#         标记已读
#         """