XZNSH_Api/user/views.py

import logging
from rest_framework import viewsets
from rest_framework.response import Response
from rest_framework import status
from app.pagination import MyPageNumberPagination
from user.models import UserProfile, Department
from django.contrib.auth import authenticate, login, logout
from app.utils import generate_token, decode_token_exp_time
from user.serializers import UserSerializer, UserFilter, DepartmentSerializer, DepartmentFilter
from rest_framework.exceptions import NotFound

# Create your views here.
logger = logging.getLogger('mylogger')


class UserViewSet(viewsets.GenericViewSet):
    # 查询类
    queryset = UserProfile.objects.filter(status=1).all().order_by("-id")  # 按照uid倒序
    # 序列化类
    serializer_class = UserSerializer
    # # 分页类
    pagination_class = MyPageNumberPagination
    #
    # 条件筛选
    filterset_class = UserFilter

    def create(self, request, *args, **kwargs):
        department = request.data.pop("department_id", None)
        request.data["department"] = department

        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response({
            "success": True,
            "msg": "新增用户成功",
            "data": serializer.data
        }, status=status.HTTP_201_CREATED)

    def list(self, request, *args, **kwargs):
        department_id = dict(request.query_params).get("department_id", None)
        if department_id and department_id != [""]:
            department_id_list = self.get_children_department(department_id)
            department_id_list.extend(department_id)

            queryset = self.filter_queryset(self.get_queryset().filter(department_id__in=department_id_list).all())
        else:
            queryset = self.filter_queryset(self.get_queryset())

        try:
            page = self.paginate_queryset(queryset)
        except NotFound as exc:
            page = None
        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)

    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

    def update(self, request, *args, **kwargs):
        department = request.data.pop("department_id", None)
        request.data["department"] = department
        partial = kwargs.pop('partial', True)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        serializer.save()

        if getattr(instance, '_prefetched_objects_cache', None):
            # If 'prefetch_related' has been applied to a queryset, we need to
            # forcibly invalidate the prefetch cache on the instance.
            instance._prefetched_objects_cache = {}

        return Response({
            "success": True,
            "msg": "新增修改成功",
            "data": serializer.data
        })

    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()  # type: UserProfile
        instance.status = 0
        instance.save()
        return Response({"success": True, "msg": "用户删除成功"})

    def get_children_department(self, parents):

        res = []
        for parent in parents:

            children_list = Department.objects.filter(parent_id=parent).values_list('id', flat=True).distinct()
            if children_list:
                res.extend(children_list)
                children_ids = self.get_children_department(children_list)
                res.extend(children_ids)

        return res


class LoginView(viewsets.ModelViewSet):

    def login(self, request, *args, **kwargs):
        """登录 POST"""
        data = request.data
        username = data.get('username')
        password = data.get('password')
        login_user = authenticate(username=username, password=password)
        if login_user and login_user.is_active and login_user.status:
            # 生成token
            token = generate_token(login_user)
            response = {
                'success': True,
                'msg': '登录成功',
                'data': {
                    'username': login_user.username,
                    'roles': ['admin'] if login_user.is_superuser else ['common'],
                    'accessToken': token,
                    'expires': decode_token_exp_time(token)
                }
            }
            return Response(response)
        else:
            response = {
                'success': False,
                'msg': '登录失败',
                'data': {
                    'username': None,
                    'roles': [],
                    'accessToken': None,
                    'expires': None
                }
            }
            return Response(response)

    def logout(self, request, *args, **kwargs):
        """登出 GET"""
        pass


class RegisterLoginViewSet(viewsets.ModelViewSet):
    def register(self, request, *args, **kwargs):
        """注册 POST"""
        # 判断用户是否为管理员
        # user = request.user
        # if not user.is_superuser:
        #     return Response({'msg': '您不是管理员，无权限添加成员'})
        data = request.data
        username = data.get('username')
        password = data.get('password')
        try:
            if UserProfile.objects.filter(username=username).first():
                return Response({'msg': '该用户名已存在，请换一个'})
            UserProfile.objects.create_user(username=username, password=password)
            return Response({'msg': '注册成功'})
        except Exception as e:
            logger.info(e)
            response = {
                "msg": f'注册失败, 原因:{e}'
            }
            return Response(response)


class DepartmentViewSet(viewsets.ModelViewSet):
    # 查询类
    queryset = Department.objects.filter(status=1).all()
    # 序列化类
    serializer_class = DepartmentSerializer
    # # 分页类
    pagination_class = MyPageNumberPagination
    # 条件筛选
    filterset_class = DepartmentFilter

    def create(self, request, *args, **kwargs):
        name = request.data.pop("department_name", None)
        if not name:
            return Response({"msg": "部门名称必须存在", "success": False})

        parent_id = request.data.pop("department_id", None) or None
        flag = self.is_exist(name, parent_id)

        if flag:
            return Response({"msg": "该部门已存在", "success": False})

        request.data["name"] = name
        request.data["parent_id"] = parent_id

        response = super().create(request, *args, **kwargs)
        data = response.data
        res = {
            "success": True,
            "msg": "部门创建成功",
            "data": data
        }
        response.data = res
        return response

    def update(self, request, *args, **kwargs):
        name = request.data.get("name", None)
        department = request.data.get("department_id", None)

        instance = self.get_object()
        if name and department != instance.parent_id:
            flag = self.is_exist(name, department)
            if flag:
                return Response({"msg": "该部门已存在", "success": False})

        # request.data["name"] = name
        kwargs["partial"] = True
        response = super().update(request, *args, **kwargs)

        data = response.data
        res = {
            "success": True,
            "msg": "部门更新成功",
            "data": data
        }
        response.data = res

        return response

    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()  # type: Department
        instance.status = 0
        instance.save()
        return Response({"success": True, "msg": "部门删除成功"})

    def is_exist(self, name, parent_id):
        is_exist = self.get_queryset().filter(status=1, name=name, parent_id=parent_id).exists()
        return is_exist

    def get_trees(self, request, *args, **kwargs):
        flag = request.query_params.get("users", False)
        roots = self.get_queryset().filter(parent_id=None)
        res = self.get_children(roots, flag)

        response = {
            'success': True,
            'msg': '查询成功',
            'data': res
        }

        return Response(response)

    def get_children(self, parents, users_flag=False):

        res = []
        for parent in parents:
            parent_data = self.serializer_class(parent).data
            if users_flag:
                users = UserProfile.objects.filter(status=1).filter(department=parent.id).all()
                users_data = UserSerializer(users, many=True).data
                parent_data["users"] = users_data

            children = self.get_queryset().filter(parent_id=parent.id)
            children_data = []
            if children:
                children_data = self.get_children(children, users_flag)
            parent_data["children"] = children_data

            res.append(parent_data)

        return res