daren/apps/template/views.py

from django.shortcuts import render
from rest_framework import viewsets, permissions, status, filters
from rest_framework.response import Response
from rest_framework.decorators import action
from django_filters.rest_framework import DjangoFilterBackend
from .models import Template
from .serializers import (
    TemplateListSerializer, 
    TemplateDetailSerializer, 
    TemplateCreateUpdateSerializer
)
from .filters import TemplateFilter
from .utils import ApiResponse
from .pagination import StandardResultsSetPagination
from rest_framework.permissions import IsAuthenticated
from apps.user.authentication import CustomTokenAuthentication
from django.db.models import Q
# Create your views here.

class TemplateViewSet(viewsets.ModelViewSet):
    """
    模板视图集
    
    提供模板的增删改查功能
    """
    queryset = Template.objects.all()
    authentication_classes = [CustomTokenAuthentication]
    permission_classes = [IsAuthenticated]
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_class = TemplateFilter
    search_fields = ['title', 'content']
    ordering_fields = ['created_at', 'updated_at', 'title']
    ordering = ['-created_at']
    pagination_class = StandardResultsSetPagination
    http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options']
    
    def get_queryset(self):
        """
        自定义查询集，返回所有模板
        """
        return Template.objects.all()
    
    def get_serializer_class(self):
        """根据不同的操作返回不同的序列化器"""
        if self.action == 'list':
            return TemplateListSerializer
        elif self.action in ['create', 'update', 'partial_update']:
            return TemplateCreateUpdateSerializer
        return TemplateDetailSerializer
    
    def list(self, request, *args, **kwargs):
        """获取所有模板，支持通过query参数mission进行筛选"""
        # 从query_params中获取mission参数
        mission = request.query_params.get('mission', None)
        if mission and mission != 'all':
            queryset = self.filter_queryset(self.get_queryset().filter(mission=mission))
        else:
            queryset = self.filter_queryset(self.get_queryset())
            
        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 ApiResponse.success(
            data=serializer.data,
            message="获取模板列表成功"
        )
    
    def retrieve(self, request, *args, **kwargs):
        """获取单个模板详情"""
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        return ApiResponse.success(
            data=serializer.data,
            message="获取模板详情成功"
        )
    
    def create(self, request, *args, **kwargs):
        """创建模板"""
        serializer = self.get_serializer(data=request.data)
        if serializer.is_valid():
            self.perform_create(serializer)
            return ApiResponse.success(
                data=serializer.data,
                message="模板创建成功",
                code=status.HTTP_201_CREATED
            )
        return ApiResponse.error(
            message="模板创建失败",
            data=serializer.errors,
            code=status.HTTP_400_BAD_REQUEST
        )
    
    def update(self, request, *args, **kwargs):
        """更新模板"""
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        if serializer.is_valid():
            self.perform_update(serializer)
            return ApiResponse.success(
                data=serializer.data,
                message="模板更新成功"
            )
        return ApiResponse.error(
            message="模板更新失败",
            data=serializer.errors,
            code=status.HTTP_400_BAD_REQUEST
        )
    
    def destroy(self, request, *args, **kwargs):
        """删除模板"""
        instance = self.get_object()
        self.perform_destroy(instance)
        return ApiResponse.success(
            data=None,
            message="模板删除成功"
        )
    
    @action(detail=False, methods=['get'])
    def mine(self, request):
        """获取所有模板"""
        templates = Template.objects.all()
        page = self.paginate_queryset(templates)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(templates, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="获取模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def public(self, request):
        """获取所有公开的模板"""
        templates = Template.objects.filter(is_public=True)
        page = self.paginate_queryset(templates)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(templates, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="获取公开模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def by_mission(self, request):
        """按任务类型获取模板"""
        mission = request.query_params.get('mission', None)
        if not mission:
            return ApiResponse.error(
                message="需要提供mission参数",
                code=status.HTTP_400_BAD_REQUEST
            )
            
        if mission == 'all':
            queryset = self.get_queryset()
        else:
            queryset = self.get_queryset().filter(mission=mission)
            
        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 ApiResponse.success(
            data=serializer.data,
            message="按任务类型获取模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def by_platform(self, request):
        """按平台获取模板"""
        platform = request.query_params.get('platform', None)
        if not platform:
            return ApiResponse.error(
                message="需要提供platform参数",
                code=status.HTTP_400_BAD_REQUEST
            )
            
        queryset = self.get_queryset().filter(platform=platform)
        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 ApiResponse.success(
            data=serializer.data,
            message="按平台获取模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def by_collaboration(self, request):
        """按合作模式获取模板"""
        collaboration_type = request.query_params.get('collaboration_type', None)
        if not collaboration_type:
            return ApiResponse.error(
                message="需要提供collaboration_type参数",
                code=status.HTTP_400_BAD_REQUEST
            )
            
        queryset = self.get_queryset().filter(collaboration_type=collaboration_type)
        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 ApiResponse.success(
            data=serializer.data,
            message="按合作模式获取模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def by_service(self, request):
        """按服务类型获取模板"""
        service = request.query_params.get('service', None)
        if not service:
            return ApiResponse.error(
                message="需要提供service参数",
                code=status.HTTP_400_BAD_REQUEST
            )
            
        queryset = self.get_queryset().filter(service=service)
        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 ApiResponse.success(
            data=serializer.data,
            message="按服务类型获取模板成功"
        )

    @action(detail=False, methods=['get'])
    def mission_options(self, request):
        """获取任务类型选项列表"""
        mission_options = [
            {'value': 'all', 'name': '全部'},
            {'value': 'initial_contact', 'name': '初步建联'},
            {'value': 'negotiation', 'name': '砍价邮件'},
            {'value': 'script', 'name': '脚本邮件'},
            {'value': 'follow_up', 'name': '合作追踪'},
        ]
        return ApiResponse.success(
            data=mission_options,
            message="获取任务类型选项列表成功"
        )

    @action(detail=False, methods=['post'])
    def search_templates(self, request):
        """
        通过POST请求查询模板
        
        请求体参数:
        - mission: 任务类型
        - query: 搜索关键词（可选，用于模糊查询标题和内容）
        - page: 页码（可选，默认1）
        - page_size: 每页数量（可选，默认10）
        """
        # 获取查询参数
        mission = request.data.get('mission', None)
        query = request.data.get('query', None)
        page = request.data.get('page', 1)
        page_size = request.data.get('page_size', 10)
        
        try:
            page = int(page)
            page_size = int(page_size)
        except (TypeError, ValueError):
            return ApiResponse.error(
                message="页码和每页数量必须是整数",
                code=status.HTTP_400_BAD_REQUEST
            )
            
        # 构建查询集
        queryset = self.get_queryset()
        
        # 按任务类型筛选
        if mission and mission != 'all':
            queryset = queryset.filter(mission=mission)
            
        # 按关键词模糊查询
        if query:
            queryset = queryset.filter(
                Q(title__icontains=query) | 
                Q(content__icontains=query)
            )
            
        # 应用其他过滤器
        queryset = self.filter_queryset(queryset)
            
        # 设置分页
        paginator = self.pagination_class()
        paginator.page_size = page_size
        paginated_queryset = paginator.paginate_queryset(queryset, request)
        
        if paginated_queryset is not None:
            serializer = self.get_serializer(paginated_queryset, many=True)
            response_data = {
                'count': paginator.page.paginator.count,
                'next': paginator.get_next_link(),
                'previous': paginator.get_previous_link(),
                'results': serializer.data
            }
            return ApiResponse.success(
                data=response_data,
                message="查询模板成功"
            )
            
        serializer = self.get_serializer(queryset, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="查询模板成功"
        )