chunyu_project/tool/views/tool_manage_view.py

from django.http import JsonResponse
from adrf.views import APIView
from rest_framework import status
from rest_framework.permissions import AllowAny, IsAuthenticated
from django.db.models import Count, Q
from ..models import ToolCategory, Tool, ToolFavorite, ToolUsageRecord
from ..serializers import ToolCategorySerializer, ToolSerializer
from drf_yasg.utils import swagger_auto_schema
from drf_yasg import openapi
from chunyu_project.common_schemas import success_response, error_response, unauthorized_response, not_found_response


class ToolCategoryListView(APIView):
    permission_classes = [AllowAny]

    @swagger_auto_schema(
        operation_summary='获取工具分类列表',
        operation_description='获取所有工具分类及其关联的工具列表',
        tags=['工具'],
        responses={200: success_response}
    )
    async def get(self, request):
        categories = [c async for c in ToolCategory.objects.prefetch_related('tools').all()]
        serializer = ToolCategorySerializer(categories, many=True)
        return JsonResponse({
            'success': True,
            'data': await serializer.adata
        })


class ToolListView(APIView):
    permission_classes = [AllowAny]

    @swagger_auto_schema(
        operation_summary='获取工具列表',
        operation_description='按分类获取工具列表，支持启用状态过滤',
        tags=['工具'],
        manual_parameters=[
            openapi.Parameter('category_id', openapi.IN_QUERY, description='分类ID', type=openapi.TYPE_INTEGER),
            openapi.Parameter('enabled_only', openapi.IN_QUERY, description='是否只显示启用的工具', type=openapi.TYPE_STRING),
            openapi.Parameter('ordering', openapi.IN_QUERY, description='排序字段', type=openapi.TYPE_STRING),
        ],
        responses={200: success_response}
    )
    async def get(self, request):
        category_id = request.query_params.get('category_id')
        enabled_only = request.query_params.get('enabled_only', 'true')
        ordering = request.query_params.get('ordering', '')

        tools = Tool.objects.select_related('category').annotate(
            annotated_favorites_count=Count('tool_favorites')
        )

        if enabled_only == 'true':
            tools = tools.filter(is_enabled=True)

        if category_id:
            tools = tools.filter(category_id=category_id)

        if ordering:
            # 支持按 favorites_count 排序
            if ordering == '-favorites_count':
                tools = tools.order_by('-annotated_favorites_count')
            elif ordering == 'favorites_count':
                tools = tools.order_by('annotated_favorites_count')
            else:
                tools = tools.order_by(ordering)
        else:
            tools = tools.order_by('sort_order', '-created_at')

        tool_list = [t async for t in tools]
        serializer = ToolSerializer(tool_list, many=True)
        data = await serializer.adata

        # 构建 favorites_count 映射
        favorites_count_map = {
            t.id: t.annotated_favorites_count for t in tool_list
        }

        if request.user.is_authenticated:
            favorite_tool_ids = set([
                tid async for tid in ToolFavorite.objects.filter(user=request.user).values_list('tool_id', flat=True)
            ])
            for item in data:
                item['is_favorited'] = item['id'] in favorite_tool_ids
                item['favorites_count'] = favorites_count_map.get(item['id'], 0)
        else:
            for item in data:
                item['is_favorited'] = False
                item['favorites_count'] = favorites_count_map.get(item['id'], 0)

        return JsonResponse({
            'success': True,
            'data': data
        })


class ToolDetailView(APIView):
    permission_classes = [AllowAny]

    @swagger_auto_schema(
        operation_summary='获取工具详情',
        operation_description='获取单个工具的详细信息',
        tags=['工具'],
        manual_parameters=[
            openapi.Parameter('pk', openapi.IN_PATH, description='工具ID', type=openapi.TYPE_INTEGER, required=True)
        ],
        responses={200: success_response, 404: not_found_response}
    )
    async def get(self, request, pk):
        try:
            tool = await Tool.objects.select_related('category').aget(pk=pk, is_enabled=True)
            serializer = ToolSerializer(tool)
            data = await serializer.adata
            if request.user.is_authenticated:
                data['is_favorited'] = await ToolFavorite.objects.filter(
                    user=request.user, tool=tool
                ).aexists()
            else:
                data['is_favorited'] = False
            data['favorites_count'] = await ToolFavorite.objects.filter(tool=tool).acount()
            return JsonResponse({
                'success': True,
                'data': data
            })
        except Tool.DoesNotExist:
            return JsonResponse(
                {'success': False, 'error': '工具不存在'},
                status=status.HTTP_404_NOT_FOUND
            )


class ToolFavoriteToggleView(APIView):
    permission_classes = [IsAuthenticated]

    @swagger_auto_schema(
        operation_summary='切换工具收藏状态',
        operation_description='添加或取消工具收藏',
        tags=['工具'],
        manual_parameters=[
            openapi.Parameter('pk', openapi.IN_PATH, description='工具ID', type=openapi.TYPE_INTEGER, required=True)
        ],
        responses={200: success_response, 401: unauthorized_response, 404: not_found_response}
    )
    async def post(self, request, pk):
        tool = await Tool.objects.filter(pk=pk, is_enabled=True).afirst()
        if not tool:
            return JsonResponse(
                {'success': False, 'error': '工具不存在'},
                status=status.HTTP_404_NOT_FOUND
            )
        fav, created = await ToolFavorite.objects.aget_or_create(user=request.user, tool=tool)
        if not created:
            await fav.adelete()
            is_favorited = False
        else:
            is_favorited = True
        favorites_count = await ToolFavorite.objects.filter(tool=tool).acount()
        return JsonResponse({
            'success': True,
            'data': {
                'id': tool.id,
                'is_favorited': is_favorited,
                'favorites_count': favorites_count,
            }
        })


class ToolFavoriteListView(APIView):
    permission_classes = [IsAuthenticated]

    @swagger_auto_schema(
        operation_summary='获取我的收藏工具列表',
        operation_description='获取当前用户收藏的所有工具',
        tags=['工具'],
        responses={200: success_response, 401: unauthorized_response}
    )
    async def get(self, request):
        favorites = [fav async for fav in ToolFavorite.objects.select_related(
            'tool', 'tool__category'
        ).filter(
            user=request.user,
            tool__is_enabled=True
        ).order_by('-created_at')]

        result = []
        for fav in favorites:
            tool_data = ToolSerializer(fav.tool).data
            tool_data['is_favorited'] = True
            tool_data['favorites_count'] = await ToolFavorite.objects.filter(tool=fav.tool).acount()
            result.append(tool_data)

        return JsonResponse({
            'success': True,
            'data': result
        })


class ToolUsageIncrementView(APIView):
    """工具使用次数递增接口"""
    permission_classes = [AllowAny]

    @swagger_auto_schema(
        operation_summary='递增工具使用次数',
        operation_description='用户点击工具时调用，递增该工具的使用次数（基于会话去重，同一会话5分钟内不重复计数）',
        tags=['工具'],
        manual_parameters=[
            openapi.Parameter('pk', openapi.IN_PATH, description='工具ID', type=openapi.TYPE_INTEGER, required=True)
        ],
        responses={200: success_response, 404: not_found_response}
    )
    async def post(self, request, pk):
        try:
            tool = await Tool.objects.aget(pk=pk, is_enabled=True)
            # 使用F()表达式避免竞态条件
            from django.db.models import F
            await Tool.objects.filter(pk=pk).aupdate(usage_count=F('usage_count') + 1)
            await tool.arefresh_from_db()
            # 写入使用日志（周榜统计用），失败不影响主流程
            try:
                await ToolUsageRecord.objects.acreate(
                    tool=tool,
                    user=request.user if request.user.is_authenticated else None,
                    session_id=request.COOKIES.get('sessionid', '')[:64] or (request.session.session_key or '')[:64],
                )
            except Exception:
                pass
            return JsonResponse({
                'success': True,
                'data': {
                    'id': tool.id,
                    'usage_count': tool.usage_count,
                }
            })
        except Tool.DoesNotExist:
            return JsonResponse(
                {'success': False, 'error': '工具不存在'},
                status=status.HTTP_404_NOT_FOUND
            )


class ToolTopView(APIView):
    """工具热榜：总榜（累计使用次数）/ 周榜（近7天使用日志聚合）"""
    permission_classes = [AllowAny]

    @swagger_auto_schema(
        operation_summary='工具热榜',
        operation_description='获取热门工具排行榜。range=all 按累计使用次数排序；range=week 按近7天使用日志聚合排序（无日志时回退到总榜）。兼容旧参数 period=total|week。返回项含 id/name/icon/usage_count/weekly_count/rank。',
        tags=['工具'],
        manual_parameters=[
            openapi.Parameter('range', openapi.IN_QUERY, description='榜单周期: all / week', type=openapi.TYPE_STRING),
            openapi.Parameter('period', openapi.IN_QUERY, description='兼容旧参数: total / week', type=openapi.TYPE_STRING),
            openapi.Parameter('limit', openapi.IN_QUERY, description='返回数量，默认10，最大50', type=openapi.TYPE_INTEGER),
        ],
        responses={200: success_response}
    )
    async def get(self, request):
        from django.utils import timezone
        from datetime import timedelta

        raw_range = request.query_params.get('range')
        raw_period = request.query_params.get('period')
        period = (raw_range or raw_period or 'all').lower()
        # 兼容映射：all <-> total
        if period == 'total':
            period = 'all'
        if period not in ('all', 'week'):
            period = 'all'
        try:
            limit = int(request.query_params.get('limit', 10))
        except (TypeError, ValueError):
            limit = 10
        limit = max(1, min(limit, 50))

        tools = Tool.objects.filter(is_enabled=True).select_related('category')
        weekly_map: dict = {}

        if period == 'week':
            week_ago = timezone.now() - timedelta(days=7)
            weekly_counts = (
                ToolUsageRecord.objects.filter(created_at__gte=week_ago)
                .values_list('tool_id')
                .annotate(cnt=Count('id'))
            )
            weekly_map = {tid: cnt async for tid, cnt in weekly_counts}
            if weekly_map:
                tool_list = [t async for t in tools]
                tool_list.sort(key=lambda t: (weekly_map.get(t.id, 0), t.usage_count), reverse=True)
                serializer = ToolSerializer(tool_list[:limit], many=True)
                data = await serializer.adata
                for rank, item in enumerate(data, start=1):
                    item['weekly_count'] = weekly_map.get(item['id'], 0)
                    item['weekly_usage'] = item['weekly_count']
                    item['rank'] = rank
                return JsonResponse({'success': True, 'data': data})
            # 无周日志时回退总榜
            period = 'all'

        tools = tools.order_by('-usage_count', 'sort_order')
        tool_list = [t async for t in tools[:limit]]
        serializer = ToolSerializer(tool_list, many=True)
        data = await serializer.adata
        for rank, item in enumerate(data, start=1):
            item['weekly_count'] = None
            item['weekly_usage'] = None
            item['rank'] = rank
        return JsonResponse({'success': True, 'data': data})


class ToolRecentView(APIView):
    """本人最近使用工具（登录，去重按最近倒序）"""
    permission_classes = [IsAuthenticated]

    @swagger_auto_schema(
        operation_summary='最近使用的工具',
        operation_description='返回当前登录用户最近使用过的工具（按工具去重，取最近一条记录倒序）。',
        tags=['工具'],
        manual_parameters=[
            openapi.Parameter('limit', openapi.IN_QUERY, description='返回数量，默认10，最大50', type=openapi.TYPE_INTEGER),
        ],
        responses={200: success_response, 401: unauthorized_response}
    )
    async def get(self, request):
        try:
            limit = int(request.query_params.get('limit', 10))
        except (TypeError, ValueError):
            limit = 10
        limit = max(1, min(limit, 50))

        records = [
            r async for r in ToolUsageRecord.objects.filter(user=request.user)
            .select_related('tool', 'tool__category')
            .order_by('-created_at', '-id')[: limit * 5]
        ]
        seen = set()
        tools = []
        for r in records:
            if r.tool_id in seen:
                continue
            if not getattr(r.tool, 'is_enabled', False):
                continue
            seen.add(r.tool_id)
            tools.append(r.tool)
            if len(tools) >= limit:
                break
        serializer = ToolSerializer(tools, many=True)
        data = await serializer.adata
        return JsonResponse({'success': True, 'data': data})