开源会议室预约小程序 + Python Django 服务端后台如何实现？

我理解你想用Python Django搭建一个会议室预约系统的服务端。这是一个很常见的需求，核心是处理好会议室资源、时间段的占用关系。下面我给你一个可以直接跑起来的Django项目骨架，重点实现了预约的核心逻辑。

1. 首先创建项目和App

django-admin startproject meeting_booking
cd meeting_booking
python manage.py startapp bookings

2. 数据模型 (bookings/models.py) 这是最核心的部分，定义了会议室和预约记录：

from django.db import models
from django.contrib.auth.models import User

class MeetingRoom(models.Model):
    """会议室表"""
    name = models.CharField('会议室名称', max_length=100)
    capacity = models.IntegerField('容纳人数')
    equipment = models.TextField('设备配置', blank=True)
    is_active = models.BooleanField('是否可用', default=True)
    
    def __str__(self):
        return f"{self.name} (最多{self.capacity}人)"

class Booking(models.Model):
    """预约记录表"""
    STATUS_CHOICES = (
        ('pending', '待确认'),
        ('confirmed', '已确认'),
        ('cancelled', '已取消'),
    )
    
    room = models.ForeignKey(MeetingRoom, on_delete=models.CASCADE, verbose_name='会议室')
    user = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name='预约人')
    title = models.CharField('会议主题', max_length=200)
    start_time = models.DateTimeField('开始时间')
    end_time = models.DateTimeField('结束时间')
    participants = models.IntegerField('参会人数', default=1)
    status = models.CharField('状态', max_length=20, choices=STATUS_CHOICES, default='pending')
    created_at = models.DateTimeField('创建时间', auto_now_add=True)
    
    class Meta:
        ordering = ['-start_time']
    
    def __str__(self):
        return f"{self.title} - {self.room.name} ({self.start_time})"

3. 关键的业务逻辑验证 (bookings/models.py 中添加) 在Booking模型中添加一个clean方法，防止时间冲突：

def clean(self):
    from django.core.exceptions import ValidationError
    
    # 检查时间是否合理
    if self.start_time >= self.end_time:
        raise ValidationError('结束时间必须晚于开始时间')
    
    # 检查会议室是否可用
    if not self.room.is_active:
        raise ValidationError('该会议室目前不可用')
    
    # 检查人数是否超过容量
    if self.participants > self.room.capacity:
        raise ValidationError(f'参会人数超过会议室容量({self.room.capacity}人)')
    
    # 检查时间冲突（排除自身和已取消的预约）
    conflicting = Booking.objects.filter(
        room=self.room,
        status__in=['pending', 'confirmed'],
        start_time__lt=self.end_time,
        end_time__gt=self.start_time
    )
    
    if self.pk:  # 如果是更新操作，排除自己
        conflicting = conflicting.exclude(pk=self.pk)
    
    if conflicting.exists():
        raise ValidationError('该时间段会议室已被预约')

4. 序列化器 (bookings/serializers.py)

from rest_framework import serializers
from .models import MeetingRoom, Booking
from django.contrib.auth.models import User

class MeetingRoomSerializer(serializers.ModelSerializer):
    class Meta:
        model = MeetingRoom
        fields = '__all__'

class BookingSerializer(serializers.ModelSerializer):
    room_name = serializers.CharField(source='room.name', read_only=True)
    username = serializers.CharField(source='user.username', read_only=True)
    
    class Meta:
        model = Booking
        fields = '__all__'
        read_only_fields = ('user', 'status', 'created_at')
    
    def validate(self, data):
        # 调用模型的clean方法进行验证
        instance = Booking(**data)
        instance.clean()
        return data

5. API视图 (bookings/views.py)

from rest_framework import viewsets, permissions, status
from rest_framework.decorators import action
from rest_framework.response import Response
from django.utils import timezone
from .models import MeetingRoom, Booking
from .serializers import MeetingRoomSerializer, BookingSerializer

class MeetingRoomViewSet(viewsets.ModelViewSet):
    queryset = MeetingRoom.objects.filter(is_active=True)
    serializer_class = MeetingRoomSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]

class BookingViewSet(viewsets.ModelViewSet):
    serializer_class = BookingSerializer
    permission_classes = [permissions.IsAuthenticated]
    
    def get_queryset(self):
        # 用户只能看到自己的预约
        return Booking.objects.filter(user=self.request.user)
    
    def perform_create(self, serializer):
        # 自动关联当前用户
        serializer.save(user=self.request.user)
    
    @action(detail=True, methods=['post'])
    def cancel(self, request, pk=None):
        booking = self.get_object()
        if booking.status == 'confirmed' and booking.start_time > timezone.now():
            booking.status = 'cancelled'
            booking.save()
            return Response({'status': '预约已取消'})
        return Response(
            {'error': '无法取消该预约'}, 
            status=status.HTTP_400_BAD_REQUEST
        )
    
    @action(detail=False, methods=['get'])
    def available(self, request):
        """查询可用会议室"""
        date = request.query_params.get('date')
        start = request.query_params.get('start')
        end = request.query_params.get('end')
        
        # 这里可以添加更复杂的查询逻辑
        rooms = MeetingRoom.objects.filter(is_active=True)
        serializer = MeetingRoomSerializer(rooms, many=True)
        return Response(serializer.data)

6. 路由配置 (meeting_booking/urls.py)

from django.contrib import admin
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from bookings.views import MeetingRoomViewSet, BookingViewSet

router = DefaultRouter()
router.register(r'rooms', MeetingRoomViewSet)
router.register(r'bookings', BookingViewSet)

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include(router.urls)),
    path('api-auth/', include('rest_framework.urls')),
]

7. 运行和测试

# 安装依赖
pip install django djangorestframework

# 数据库迁移
python manage.py makemigrations
python manage.py migrate

# 创建超级用户（用于后台管理）
python manage.py createsuperuser

# 运行服务
python manage.py runserver

核心API端点：

• GET /api/rooms/ - 获取所有会议室
• POST /api/bookings/ - 创建预约（自动关联当前用户）
• GET /api/bookings/available/?date=2024-01-01&start=09:00&end=10:00 - 查询可用会议室
• POST /api/bookings/{id}/cancel/ - 取消预约

给小程序端的接口建议：

1. 用户登录后获取token
2. 查询会议室列表
3. 提交预约时传递：room_id, title, start_time, end_time, participants
4. 可以定时同步用户的预约状态

这个实现包含了最核心的会议室预约逻辑，特别是时间冲突检测。你可以基于这个骨架继续扩展，比如添加邮件通知、审批流程、重复预约等功能。

总结：先跑通这个基础版本，再根据实际需求添加功能。