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

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

backend/apps/featured_services/__init__.py

@@ -0,0 +1 @@
+# Featured services app

backend/apps/featured_services/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class FeaturedServicesConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.featured_services'
+    verbose_name = '特色服务'

backend/apps/featured_services/models.py

@@ -0,0 +1,149 @@
+from django.db import models
+from django.conf import settings
+from apps.regions.models import Region
+
+
+class FeaturedService(models.Model):
+    """Model for featured services."""
+
+    SERVICE_CATEGORY_CHOICES = [
+        ('clothing', '衣'),
+        ('food', '食'),
+        ('accommodation', '住'),
+        ('transport', '行'),
+        ('entertainment', '娱乐'),
+        ('tourism', '旅游'),
+        ('culture', '文化'),
+    ]
+
+    STATUS_CHOICES = [
+        ('draft', '草稿'),
+        ('pending_moderator', '待版主审核'),
+        ('pending_ai', '待AI审核'),
+        ('published', '已发布'),
+        ('rejected', '已拒绝'),
+    ]
+
+    MODERATOR_STATUS_CHOICES = [
+        ('pending', '待审核'),
+        ('approved', '通过'),
+        ('rejected', '拒绝'),
+    ]
+
+    AI_STATUS_CHOICES = [
+        ('pending', '待审核'),
+        ('approved', '通过'),
+        ('rejected', '拒绝'),
+    ]
+
+    name = models.CharField(max_length=200, verbose_name='服务名称')
+    description = models.TextField(verbose_name='服务描述')
+    region = models.ForeignKey(
+        Region,
+        on_delete=models.CASCADE,
+        related_name='featured_services',
+        verbose_name='所属版块'
+    )
+    category = models.CharField(
+        max_length=20,
+        choices=SERVICE_CATEGORY_CHOICES,
+        verbose_name='服务分类'
+    )
+    address = models.CharField(max_length=200, null=True, blank=True, verbose_name='地址')
+    contact = models.CharField(max_length=100, null=True, blank=True, verbose_name='联系方式')
+    image = models.ImageField(upload_to='services/', null=True, blank=True, verbose_name='图片')
+    submitter = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name='submitted_services',
+        verbose_name='提交者'
+    )
+
+    # Moderator review
+    moderator_reviewer = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='moderated_services',
+        verbose_name='版主审核人'
+    )
+    moderator_status = models.CharField(
+        max_length=20,
+        choices=MODERATOR_STATUS_CHOICES,
+        default='pending',
+        verbose_name='版主审核状态'
+    )
+    moderator_reviewed_at = models.DateTimeField(null=True, blank=True, verbose_name='版主审核时间')
+    moderator_rejection_reason = models.TextField(null=True, blank=True, verbose_name='版主拒绝原因')
+
+    # AI review
+    ai_status = models.CharField(
+        max_length=20,
+        choices=AI_STATUS_CHOICES,
+        default='pending',
+        verbose_name='AI审核状态'
+    )
+    ai_reviewed_at = models.DateTimeField(null=True, blank=True, verbose_name='AI审核时间')
+    ai_rejection_reason = models.TextField(null=True, blank=True, verbose_name='AI拒绝原因')
+
+    # Publish status
+    publish_status = models.CharField(
+        max_length=20,
+        choices=STATUS_CHOICES,
+        default='draft',
+        verbose_name='发布状态'
+    )
+    published_at = models.DateTimeField(null=True, blank=True, verbose_name='发布时间')
+
+    created_at = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
+    updated_at = models.DateTimeField(auto_now=True, verbose_name='更新时间')
+
+    class Meta:
+        db_table = 'featured_services'
+        verbose_name = '特色服务'
+        verbose_name_plural = '特色服务'
+        ordering = ['-created_at']
+
+    def __str__(self):
+        return self.name
+
+    def submit_for_review(self):
+        """Submit service for moderator review."""
+        self.publish_status = 'pending_moderator'
+        self.save()
+
+    def approve_moderator(self, reviewer, reason=''):
+        """Approve service by moderator."""
+        self.moderator_status = 'approved'
+        self.moderator_reviewer = reviewer
+        self.moderator_reviewed_at = timezone.now()
+        self.moderator_rejection_reason = reason
+        self.publish_status = 'pending_ai'
+        self.save()
+
+    def reject_moderator(self, reviewer, reason):
+        """Reject service by moderator."""
+        self.moderator_status = 'rejected'
+        self.moderator_reviewer = reviewer
+        self.moderator_reviewed_at = timezone.now()
+        self.moderator_rejection_reason = reason
+        self.publish_status = 'rejected'
+        self.save()
+
+    def approve_ai(self, reason=''):
+        """Approve service by AI."""
+        self.ai_status = 'approved'
+        self.ai_reviewed_at = timezone.now()
+        self.ai_rejection_reason = reason
+        self.publish_status = 'published'
+        self.published_at = timezone.now()
+        self.save()
+
+    def reject_ai(self, reason):
+        """Reject service by AI."""
+        self.ai_status = 'rejected'
+        self.ai_reviewed_at = timezone.now()
+        self.ai_rejection_reason = reason
+        self.publish_status = 'rejected'
+        self.save()

backend/apps/featured_services/serializers.py

@@ -0,0 +1,66 @@
+from rest_framework import serializers
+from .models import FeaturedService
+
+
+class FeaturedServiceSerializer(serializers.ModelSerializer):
+    """Serializer for FeaturedService model."""
+
+    category_display = serializers.CharField(source='get_category_display', read_only=True)
+    status_display = serializers.CharField(source='get_publish_status_display', read_only=True)
+    moderator_status_display = serializers.CharField(source='get_moderator_status_display', read_only=True)
+    ai_status_display = serializers.CharField(source='get_ai_status_display', read_only=True)
+    submitter_username = serializers.CharField(source='submitter.username', read_only=True)
+    region_name = serializers.CharField(source='region.name', read_only=True)
+
+    class Meta:
+        model = FeaturedService
+        fields = ('id', 'name', 'description', 'region', 'region_name', 'category', 'category_display',
+                  'address', 'contact', 'image', 'submitter', 'submitter_username',
+                  'moderator_status', 'moderator_status_display', 'moderator_reviewer',
+                  'moderator_reviewed_at', 'moderator_rejection_reason',
+                  'ai_status', 'ai_status_display', 'ai_reviewed_at', 'ai_rejection_reason',
+                  'publish_status', 'status_display', 'published_at', 'created_at', 'updated_at')
+        read_only_fields = ('id', 'submitter', 'moderator_reviewer', 'moderator_reviewed_at',
+                          'ai_reviewed_at', 'published_at', 'created_at', 'updated_at')
+
+
+class FeaturedServiceCreateSerializer(serializers.ModelSerializer):
+    """Serializer for creating featured services."""
+
+    class Meta:
+        model = FeaturedService
+        fields = ('name', 'description', 'region', 'category', 'address', 'contact', 'image')
+
+    def create(self, validated_data):
+        validated_data['submitter'] = self.context['request'].user
+        return super().create(validated_data)
+
+
+class FeaturedServiceUpdateSerializer(serializers.ModelSerializer):
+    """Serializer for updating featured services."""
+
+    class Meta:
+        model = FeaturedService
+        fields = ('name', 'description', 'category', 'address', 'contact', 'image')
+
+
+class FeaturedServiceReviewSerializer(serializers.Serializer):
+    """Serializer for service review actions."""
+
+    action = serializers.ChoiceField(choices=['approve', 'reject'])
+    reason = serializers.CharField(required=False, allow_blank=True)
+
+
+class FeaturedServiceListSerializer(serializers.ModelSerializer):
+    """Simplified serializer for service list."""
+
+    category_display = serializers.CharField(source='get_category_display', read_only=True)
+    submitter_username = serializers.CharField(source='submitter.username', read_only=True)
+    region_name = serializers.CharField(source='region.name', read_only=True)
+
+    class Meta:
+        model = FeaturedService
+        fields = ('id', 'name', 'category', 'category_display', 'image',
+                  'submitter', 'submitter_username', 'region', 'region_name',
+                  'publish_status', 'created_at')
+        read_only_fields = ('id', 'created_at')

backend/apps/featured_services/urls.py

@@ -0,0 +1,10 @@
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from .views import FeaturedServiceViewSet
+
+router = DefaultRouter()
+router.register(r'services', FeaturedServiceViewSet, basename='featured_service')
+
+urlpatterns = [
+    path('', include(router.urls)),
+]

backend/apps/featured_services/views.py

@@ -0,0 +1,227 @@
+from rest_framework import viewsets, permissions, status, filters
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from django.db.models import Q
+from .models import FeaturedService
+from .serializers import (
+    FeaturedServiceSerializer,
+    FeaturedServiceCreateSerializer,
+    FeaturedServiceUpdateSerializer,
+    FeaturedServiceReviewSerializer,
+    FeaturedServiceListSerializer
+)
+
+
+class FeaturedServiceViewSet(viewsets.ModelViewSet):
+    """ViewSet for FeaturedService model."""
+
+    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
+    filter_backends = [filters.SearchFilter, filters.OrderingFilter, filters.DjangoFilterBackend]
+    search_fields = ['name', 'description']
+    filterset_fields = ['category', 'region', 'publish_status']
+    ordering_fields = ['created_at', 'updated_at', 'published_at']
+    ordering = ['-created_at']
+
+    def get_queryset(self):
+        queryset = FeaturedService.objects.select_related('submitter', 'region', 'moderator_reviewer')
+
+        # Only show published services to non-authenticated users
+        if not self.request.user.is_authenticated:
+            return queryset.filter(publish_status='published')
+
+        # Show all for admins
+        if self.request.user.is_admin():
+            return queryset
+
+        # Show own services + published services for regular users
+        return queryset.filter(
+            Q(submitter=self.request.user) |
+            Q(publish_status='published')
+        ).distinct()
+
+    def get_serializer_class(self):
+        if self.action == 'create':
+            return FeaturedServiceCreateSerializer
+        elif self.action in ['update', 'partial_update']:
+            return FeaturedServiceUpdateSerializer
+        elif self.action == 'list':
+            return FeaturedServiceListSerializer
+        elif self.action in ['approve', 'reject', 'submit']:
+            return FeaturedServiceReviewSerializer
+        return FeaturedServiceSerializer
+
+    def perform_create(self, serializer):
+        serializer.save(submitter=self.request.user)
+
+    def perform_update(self, serializer):
+        # Only allow updating own services or by admin
+        if (not self.request.user.is_admin() and
+            str(serializer.instance.submitter.id) != str(self.request.user.id)):
+            from rest_framework.exceptions import PermissionDenied
+            raise PermissionDenied("You can only update your own services")
+        serializer.save()
+
+    def perform_destroy(self, instance):
+        # Only allow deleting own services or by admin
+        if (not self.request.user.is_admin() and
+            str(instance.submitter.id) != str(self.request.user.id)):
+            from rest_framework.exceptions import PermissionDenied
+            raise PermissionDenied("You can only delete your own services")
+        instance.delete()
+
+    @action(detail=True, methods=['post'])
+    def submit(self, request, pk=None):
+        """Submit service for review."""
+        service = self.get_object()
+        if service.submitter != request.user:
+            return Response(
+                {'detail': 'You can only submit your own services'},
+                status=status.HTTP_403_FORBIDDEN
+            )
+        service.submit_for_review()
+        return Response({'message': 'Service submitted for review'})
+
+    @action(detail=True, methods=['post'])
+    def approve(self, request, pk=None):
+        """Approve service (moderator only)."""
+        service = self.get_object()
+        serializer = self.get_serializer(data=request.data)
+
+        if not serializer.is_valid():
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+        if not request.user.is_moderator():
+            return Response(
+                {'detail': 'Only moderators can approve services'},
+                status=status.HTTP_403_FORBIDDEN
+            )
+
+        # Check if moderator has permission for this region
+        from apps.moderation.models import ModeratorPermission
+        has_permission = ModeratorPermission.objects.filter(
+            moderator=request.user,
+            region=service.region,
+            status='active'
+        ).exists()
+
+        if not has_permission:
+            return Response(
+                {'detail': 'You do not have permission to approve services in this region'},
+                status=status.HTTP_403_FORBIDDEN
+            )
+
+        service.approve_moderator(
+            reviewer=request.user,
+            reason=serializer.validated_data.get('reason', '')
+        )
+        return Response({'message': 'Service approved'})
+
+    @action(detail=True, methods=['post'])
+    def reject(self, request, pk=None):
+        """Reject service (moderator only)."""
+        service = self.get_object()
+        serializer = self.get_serializer(data=request.data)
+
+        if not serializer.is_valid():
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+        if not request.user.is_moderator():
+            return Response(
+                {'detail': 'Only moderators can reject services'},
+                status=status.HTTP_403_FORBIDDEN
+            )
+
+        # Check if moderator has permission for this region
+        from apps.moderation.models import ModeratorPermission
+        has_permission = ModeratorPermission.objects.filter(
+            moderator=request.user,
+            region=service.region,
+            status='active'
+        ).exists()
+
+        if not has_permission:
+            return Response(
+                {'detail': 'You do not have permission to reject services in this region'},
+                status=status.HTTP_403_FORBIDDEN
+            )
+
+        service.reject_moderator(
+            reviewer=request.user,
+            reason=serializer.validated_data.get('reason', 'Required reason')
+        )
+        return Response({'message': 'Service rejected'})
+
+    @action(detail=True, methods=['get'])
+    def comments(self, request, pk=None):
+        """Get comments for a service."""
+        service = self.get_object()
+        from apps.interactions.serializers import CommentSerializer
+        from apps.interactions.models import Comment
+        comments = Comment.objects.filter(
+            target_type='service',
+            target_id=service.id,
+            ai_status='approved'
+        )
+        serializer = CommentSerializer(comments, many=True)
+        return Response(serializer.data)
+
+    @action(detail=True, methods=['post'])
+    def like(self, request, pk=None):
+        """Like or unlike a service."""
+        service = self.get_object()
+        from apps.interactions.models import Like
+
+        like, created = Like.objects.get_or_create(
+            user=request.user,
+            target_type='service',
+            target_id=service.id
+        )
+
+        if not created:
+            like.delete()
+            return Response({'message': 'Unliked', 'liked': False})
+
+        return Response({'message': 'Liked', 'liked': True})
+
+    @action(detail=True, methods=['post'])
+    def rate(self, request, pk=None):
+        """Rate a service."""
+        service = self.get_object()
+        from apps.interactions.serializers import RatingCreateSerializer
+
+        serializer = RatingCreateSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(target_type='service', target_id=service.id)
+            return Response({'message': 'Rating saved'})
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=True, methods=['get'])
+    def stats(self, request, pk=None):
+        """Get service statistics."""
+        service = self.get_object()
+        from apps.interactions.models import Like, Comment, Rating
+
+        likes_count = Like.objects.filter(
+            target_type='service',
+            target_id=service.id
+        ).count()
+
+        comments_count = Comment.objects.filter(
+            target_type='service',
+            target_id=service.id,
+            ai_status='approved'
+        ).count()
+
+        ratings = Rating.objects.filter(
+            target_type='service',
+            target_id=service.id
+        )
+
+        avg_rating = ratings.aggregate(avg=models.Avg('score'))['avg'] or 0
+
+        return Response({
+            'likes_count': likes_count,
+            'comments_count': comments_count,
+            'avg_rating': round(avg_rating, 1),
+            'ratings_count': ratings.count(),
+        })