Initial commit: React + Django 城市手册项目

- Django 4.2 + DRF + JWT + GraphQL
- React 18 + MobX + styled-components
- PostgreSQL 数据库
- Docker + Docker Compose + Nginx
- 完整的功能模块（用户、版块、文章、服务、交互、版主管理）
- 完整的文档（需求、部署、测试）

backend/apps/interactions/__init__.py

@@ -0,0 +1 @@
+# Interactions app

backend/apps/interactions/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class InteractionsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.interactions'
+    verbose_name = '交互功能'

backend/apps/interactions/models.py

@@ -0,0 +1,159 @@
+from django.db import models
+from django.conf import settings
+
+
+class Comment(models.Model):
+    """Model for comments."""
+
+    AI_STATUS_CHOICES = [
+        ('pending', '待审核'),
+        ('approved', '通过'),
+        ('rejected', '拒绝'),
+    ]
+
+    TARGET_TYPE_CHOICES = [
+        ('article', '文章'),
+        ('service', '特色服务'),
+    ]
+
+    content = models.TextField(verbose_name='评论内容')
+    target_type = models.CharField(
+        max_length=20,
+        choices=TARGET_TYPE_CHOICES,
+        verbose_name='评论对象类型'
+    )
+    target_id = models.PositiveIntegerField(verbose_name='评论对象ID')
+    author = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name='comments',
+        verbose_name='评论者'
+    )
+    ai_status = models.CharField(
+        max_length=20,
+        choices=AI_STATUS_CHOICES,
+        default='pending',
+        verbose_name='AI审核状态'
+    )
+    ai_rejection_reason = models.TextField(null=True, blank=True, verbose_name='AI拒绝原因')
+    created_at = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
+
+    class Meta:
+        db_table = 'comments'
+        verbose_name = '评论'
+        verbose_name_plural = '评论'
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f'{self.author.username} on {self.target_type} {self.target_id}'
+
+    def approve_ai(self):
+        """Approve comment by AI."""
+        self.ai_status = 'approved'
+        self.save()
+
+    def reject_ai(self, reason):
+        """Reject comment by AI."""
+        self.ai_status = 'rejected'
+        self.ai_rejection_reason = reason
+        self.save()
+
+
+class Rating(models.Model):
+    """Model for ratings."""
+
+    TARGET_TYPE_CHOICES = [
+        ('region', '城市'),
+        ('service', '特色服务'),
+    ]
+
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name='ratings',
+        verbose_name='用户'
+    )
+    target_type = models.CharField(
+        max_length=20,
+        choices=TARGET_TYPE_CHOICES,
+        verbose_name='评分对象类型'
+    )
+    target_id = models.PositiveIntegerField(verbose_name='评分对象ID')
+    score = models.PositiveSmallIntegerField(verbose_name='评分值')
+    created_at = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
+
+    class Meta:
+        db_table = 'ratings'
+        verbose_name = '评分'
+        verbose_name_plural = '评分'
+        unique_together = ['user', 'target_type', 'target_id']
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f'{self.user.username} rated {self.target_type} {self.target_id}: {self.score}'
+
+
+class Like(models.Model):
+    """Model for likes."""
+
+    TARGET_TYPE_CHOICES = [
+        ('article', '文章'),
+        ('service', '特色服务'),
+    ]
+
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name='likes',
+        verbose_name='用户'
+    )
+    target_type = models.CharField(
+        max_length=20,
+        choices=TARGET_TYPE_CHOICES,
+        verbose_name='点赞对象类型'
+    )
+    target_id = models.PositiveIntegerField(verbose_name='点赞对象ID')
+    created_at = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
+
+    class Meta:
+        db_table = 'likes'
+        verbose_name = '点赞'
+        verbose_name_plural = '点赞'
+        unique_together = ['user', 'target_type', 'target_id']
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f'{self.user.username} likes {self.target_type} {self.target_id}'
+
+
+class Favorite(models.Model):
+    """Model for favorites."""
+
+    TARGET_TYPE_CHOICES = [
+        ('region', '城市'),
+        ('service', '特色服务'),
+    ]
+
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name='favorites',
+        verbose_name='用户'
+    )
+    target_type = models.CharField(
+        max_length=20,
+        choices=TARGET_TYPE_CHOICES,
+        verbose_name='收藏对象类型'
+    )
+    target_id = models.PositiveIntegerField(verbose_name='收藏对象ID')
+    created_at = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
+
+    class Meta:
+        db_table = 'favorites'
+        verbose_name = '收藏'
+        verbose_name_plural = '收藏'
+        unique_together = ['user', 'target_type', 'target_id']
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return f'{self.user.username} favorited {self.target_type} {self.target_id}'

backend/apps/interactions/serializers.py

@@ -0,0 +1,117 @@
+from rest_framework import serializers
+from .models import Comment, Rating, Like, Favorite
+
+
+class CommentSerializer(serializers.ModelSerializer):
+    """Serializer for Comment model."""
+
+    target_type_display = serializers.CharField(source='get_target_type_display', read_only=True)
+    ai_status_display = serializers.CharField(source='get_ai_status_display', read_only=True)
+    author_username = serializers.CharField(source='author.username', read_only=True)
+
+    class Meta:
+        model = Comment
+        fields = ('id', 'content', 'target_type', 'target_type_display', 'target_id',
+                  'author', 'author_username', 'ai_status', 'ai_status_display',
+                  'ai_rejection_reason', 'created_at')
+        read_only_fields = ('id', 'author', 'ai_status', 'ai_rejection_reason', 'created_at')
+
+    def create(self, validated_data):
+        validated_data['author'] = self.context['request'].user
+        return super().create(validated_data)
+
+
+class CommentCreateSerializer(serializers.ModelSerializer):
+    """Serializer for creating comments."""
+
+    class Meta:
+        model = Comment
+        fields = ('content', 'target_type', 'target_id')
+
+    def create(self, validated_data):
+        validated_data['author'] = self.context['request'].user
+        return super().create(validated_data)
+
+
+class RatingSerializer(serializers.ModelSerializer):
+    """Serializer for Rating model."""
+
+    target_type_display = serializers.CharField(source='get_target_type_display', read_only=True)
+    user_username = serializers.CharField(source='user.username', read_only=True)
+
+    class Meta:
+        model = Rating
+        fields = ('id', 'user', 'user_username', 'target_type', 'target_type_display',
+                  'target_id', 'score', 'created_at')
+        read_only_fields = ('id', 'user', 'created_at')
+
+    def create(self, validated_data):
+        validated_data['user'] = self.context['request'].user
+        return super().create(validated_data)
+
+
+class RatingCreateSerializer(serializers.ModelSerializer):
+    """Serializer for creating/updating ratings."""
+
+    class Meta:
+        model = Rating
+        fields = ('target_type', 'target_id', 'score')
+
+    def create(self, validated_data):
+        validated_data['user'] = self.context['request'].user
+        # Check if rating already exists
+        Rating.objects.filter(
+            user=validated_data['user'],
+            target_type=validated_data['target_type'],
+            target_id=validated_data['target_id']
+        ).delete()
+        return super().create(validated_data)
+
+
+class LikeSerializer(serializers.ModelSerializer):
+    """Serializer for Like model."""
+
+    target_type_display = serializers.CharField(source='get_target_type_display', read_only=True)
+    user_username = serializers.CharField(source='user.username', read_only=True)
+
+    class Meta:
+        model = Like
+        fields = ('id', 'user', 'user_username', 'target_type', 'target_type_display',
+                  'target_id', 'created_at')
+        read_only_fields = ('id', 'user', 'created_at')
+
+
+class FavoriteSerializer(serializers.ModelSerializer):
+    """Serializer for Favorite model."""
+
+    target_type_display = serializers.CharField(source='get_target_type_display', read_only=True)
+    user_username = serializers.CharField(source='user.username', read_only=True)
+
+    class Meta:
+        model = Favorite
+        fields = ('id', 'user', 'user_username', 'target_type', 'target_type_display',
+                  'target_id', 'created_at')
+        read_only_fields = ('id', 'user', 'created_at')
+
+
+class FavoriteCreateSerializer(serializers.ModelSerializer):
+    """Serializer for creating/removing favorites."""
+
+    class Meta:
+        model = Favorite
+        fields = ('target_type', 'target_id')
+
+    def create(self, validated_data):
+        validated_data['user'] = self.context['request'].user
+        # Check if favorite already exists
+        existing = Favorite.objects.filter(
+            user=validated_data['user'],
+            target_type=validated_data['target_type'],
+            target_id=validated_data['target_id']
+        ).first()
+
+        if existing:
+            existing.delete()
+            return None  # Return None to indicate removal
+
+        return super().create(validated_data)

backend/apps/interactions/urls.py

@@ -0,0 +1,18 @@
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from .views import (
+    CommentViewSet,
+    RatingViewSet,
+    LikeViewSet,
+    FavoriteViewSet
+)
+
+router = DefaultRouter()
+router.register(r'comments', CommentViewSet, basename='comment')
+router.register(r'ratings', RatingViewSet, basename='rating')
+router.register(r'likes', LikeViewSet, basename='like')
+router.register(r'favorites', FavoriteViewSet, basename='favorite')
+
+urlpatterns = [
+    path('', include(router.urls)),
+]

backend/apps/interactions/views.py

@@ -0,0 +1,226 @@
+from rest_framework import viewsets, permissions, status, filters
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from .models import Comment, Rating, Like, Favorite
+from .serializers import (
+    CommentSerializer,
+    CommentCreateSerializer,
+    RatingSerializer,
+    RatingCreateSerializer,
+    LikeSerializer,
+    FavoriteSerializer,
+    FavoriteCreateSerializer
+)
+
+
+class CommentViewSet(viewsets.ModelViewSet):
+    """ViewSet for Comment model."""
+
+    queryset = Comment.objects.select_related('author')
+    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
+    filter_backends = [filters.SearchFilter, filters.OrderingFilter, filters.DjangoFilterBackend]
+    search_fields = ['content']
+    filterset_fields = ['target_type', 'target_id', 'ai_status']
+    ordering_fields = ['created_at']
+    ordering = ['-created_at']
+
+    def get_queryset(self):
+        # Only show approved comments
+        if not self.request.user.is_authenticated:
+            return self.queryset.filter(ai_status='approved')
+
+        # Admins see all
+        if self.request.user.is_admin():
+            return self.queryset
+
+        # Regular users see approved + their own
+        return self.queryset.filter(
+            Q(ai_status='approved') |
+            Q(author=self.request.user)
+        ).distinct()
+
+    def get_serializer_class(self):
+        if self.action == 'create':
+            return CommentCreateSerializer
+        return CommentSerializer
+
+    def perform_create(self, serializer):
+        serializer.save()
+
+    def perform_update(self, serializer):
+        # Only allow updating own comments
+        if str(serializer.instance.author.id) != str(self.request.user.id):
+            from rest_framework.exceptions import PermissionDenied
+            raise PermissionDenied("You can only update your own comments")
+        serializer.save()
+
+    def perform_destroy(self, instance):
+        # Only allow deleting own comments or by admin
+        if (not self.request.user.is_admin() and
+            str(instance.author.id) != str(self.request.user.id)):
+            from rest_framework.exceptions import PermissionDenied
+            raise PermissionDenied("You can only delete your own comments")
+        instance.delete()
+
+    @action(detail=True, methods=['post'])
+    def approve_ai(self, request, pk=None):
+        """Approve comment by AI (simulated)."""
+        if not request.user.is_ai_auditor():
+            return Response(
+                {'detail': 'Only AI auditors can approve comments'},
+                status=status.HTTP_403_FORBIDDEN
+            )
+
+        comment = self.get_object()
+        comment.approve_ai()
+        return Response({'message': 'Comment approved by AI'})
+
+    @action(detail=True, methods=['post'])
+    def reject_ai(self, request, pk=None):
+        """Reject comment by AI (simulated)."""
+        if not request.user.is_ai_auditor():
+            return Response(
+                {'detail': 'Only AI auditors can reject comments'},
+                status=status.HTTP_403_FORBIDDEN
+            )
+
+        comment = self.get_object()
+        reason = request.data.get('reason', 'Content violates guidelines')
+        comment.reject_ai(reason)
+        return Response({'message': 'Comment rejected by AI'})
+
+
+class RatingViewSet(viewsets.ModelViewSet):
+    """ViewSet for Rating model."""
+
+    queryset = Rating.objects.select_related('user')
+    serializer_class = RatingSerializer
+    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
+    filter_backends = [filters.SearchFilter, filters.OrderingFilter, filters.DjangoFilterBackend]
+    filterset_fields = ['target_type', 'target_id', 'user']
+    ordering_fields = ['created_at']
+    ordering = ['-created_at']
+
+    def get_queryset(self):
+        # Admins see all
+        if self.request.user.is_admin():
+            return self.queryset
+
+        # Regular users see their own ratings
+        return self.queryset.filter(user=self.request.user)
+
+    def get_serializer_class(self):
+        if self.action == 'create':
+            return RatingCreateSerializer
+        return RatingSerializer
+
+    def perform_create(self, serializer):
+        serializer.save()
+
+    def perform_destroy(self, instance):
+        # Only allow deleting own ratings
+        if str(instance.user.id) != str(self.request.user.id):
+            from rest_framework.exceptions import PermissionDenied
+            raise PermissionDenied("You can only delete your own ratings")
+        instance.delete()
+
+    @action(detail=False, methods=['get'])
+    def my_ratings(self, request):
+        """Get current user's ratings."""
+        ratings = Rating.objects.filter(user=request.user).select_related()
+        serializer = self.get_serializer(ratings, many=True)
+        return Response(serializer.data)
+
+
+class LikeViewSet(viewsets.ModelViewSet):
+    """ViewSet for Like model."""
+
+    queryset = Like.objects.select_related('user')
+    serializer_class = LikeSerializer
+    permission_classes = [permissions.IsAuthenticated]
+    filter_backends = [filters.OrderingFilter, filters.DjangoFilterBackend]
+    filterset_fields = ['target_type', 'target_id', 'user']
+    ordering_fields = ['created_at']
+    ordering = ['-created_at']
+
+    def get_queryset(self):
+        # Admins see all
+        if self.request.user.is_admin():
+            return self.queryset
+
+        # Regular users see their own likes
+        return self.queryset.filter(user=self.request.user)
+
+    @action(detail=False, methods=['post'])
+    def toggle(self, request):
+        """Toggle like on a target."""
+        target_type = request.data.get('target_type')
+        target_id = request.data.get('target_id')
+
+        if not target_type or not target_id:
+            return Response(
+                {'detail': 'target_type and target_id are required'},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        like, created = Like.objects.get_or_create(
+            user=request.user,
+            target_type=target_type,
+            target_id=target_id
+        )
+
+        if not created:
+            like.delete()
+            return Response({'message': 'Unliked', 'liked': False})
+
+        return Response({'message': 'Liked', 'liked': True})
+
+    @action(detail=False, methods=['get'])
+    def my_likes(self, request):
+        """Get current user's likes."""
+        likes = Like.objects.filter(user=request.user).select_related()
+        serializer = self.get_serializer(likes, many=True)
+        return Response(serializer.data)
+
+
+class FavoriteViewSet(viewsets.ModelViewSet):
+    """ViewSet for Favorite model."""
+
+    queryset = Favorite.objects.select_related('user')
+    serializer_class = FavoriteSerializer
+    permission_classes = [permissions.IsAuthenticated]
+    filter_backends = [filters.OrderingFilter, filters.DjangoFilterBackend]
+    filterset_fields = ['target_type', 'target_id', 'user']
+    ordering_fields = ['created_at']
+    ordering = ['-created_at']
+
+    def get_queryset(self):
+        # Admins see all
+        if self.request.user.is_admin():
+            return self.queryset
+
+        # Regular users see their own favorites
+        return self.queryset.filter(user=self.request.user)
+
+    def get_serializer_class(self):
+        if self.action == 'create':
+            return FavoriteCreateSerializer
+        return FavoriteSerializer
+
+    @action(detail=False, methods=['post'])
+    def toggle(self, request):
+        """Toggle favorite on a target."""
+        serializer = FavoriteCreateSerializer(data=request.data)
+        if serializer.is_valid():
+            result = serializer.save()
+            if result is None:
+                return Response({'message': 'Unfavorited', 'favorited': False})
+            return Response({'message': 'Favorited', 'favorited': True})
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=False, methods=['get'])
+    def my_favorites(self, request):
+        """Get current user's favorites."""
+        favorites = Favorite.objects.filter(user=request.user).select_related()
+        serializer = FavoriteSerializer(favorites, many=True)
+        return Response(serializer.data)