Как обновить данные пользователя в REST?

Обновление данных пользователя в REST API

Существует два основных подхода для обновления данных в REST: PUT (полное обновление) и PATCH (частичное). Правильная реализация зависит от требований API.

1. Различие между PUT и PATCH

PUT — полное обновление (требует все поля):

PUT /api/v1/users/123
Content-Type: application/json

{
  "name": "Иван Петров",
  "email": "ivan@example.com",
  "age": 30,
  "phone": "+7-900-000-00-00"
}

PATCH — частичное обновление (обновляет только переданные поля):

PATCH /api/v1/users/123
Content-Type: application/json

{
  "email": "newemail@example.com"
}

2. Реализация на Django REST Framework

from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated, IsAdminUser
from .models import User
from .serializers import UserSerializer, UserUpdateSerializer

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    permission_classes = [IsAuthenticated]
    
    def get_serializer_class(self):
        """Разные сериализаторы для разных операций."""
        if self.action in ['update', 'partial_update']:
            return UserUpdateSerializer
        return UserSerializer
    
    def get_object(self):
        """Получаем объект пользователя для обновления."""
        obj = super().get_object()
        # Проверяем права: только свои данные или администратор
        if self.request.user != obj and not self.request.user.is_staff:
            self.permission_denied(
                self.request,
                'Вы не можете обновить данные другого пользователя'
            )
        return obj
    
    def update(self, request, *args, **kwargs):
        """PUT — полное обновление всех полей."""
        partial = False
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)
        return Response(serializer.data)
    
    def partial_update(self, request, *args, **kwargs):
        """PATCH — частичное обновление."""
        partial = True
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)
        return Response(serializer.data)
    
    def perform_update(self, serializer):
        """Переопределяем для логирования или дополнительной логики."""
        old_data = {field: getattr(serializer.instance, field) 
                   for field in serializer.validated_data.keys()}
        
        serializer.save()
        
        # Логируем изменения
        logger.info(
            f'User {self.request.user.id} updated user {serializer.instance.id}',
            extra={'old_data': old_data, 'new_data': serializer.validated_data}
        )

3. Сериализаторы для обновления

from rest_framework import serializers
from django.contrib.auth.models import User
from django.core.validators import EmailValidator

class UserSerializer(serializers.ModelSerializer):
    """Сериализатор для чтения данных."""
    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'first_name', 'last_name', 'date_joined']
        read_only_fields = ['id', 'date_joined']

class UserUpdateSerializer(serializers.ModelSerializer):
    """Сериализатор для обновления с дополнительной валидацией."""
    email = serializers.EmailField(validators=[EmailValidator()])
    
    class Meta:
        model = User
        fields = ['username', 'email', 'first_name', 'last_name']
    
    def validate_username(self, value):
        """Проверяем, что username не занят."""
        user = self.instance
        if User.objects.exclude(pk=user.pk).filter(username=value).exists():
            raise serializers.ValidationError('Это имя пользователя уже занято')
        return value
    
    def validate_email(self, value):
        """Проверяем, что email не занят."""
        user = self.instance
        if User.objects.exclude(pk=user.pk).filter(email=value).exists():
            raise serializers.ValidationError('Этот email уже зарегистрирован')
        return value
    
    def validate(self, data):
        """Кросс-валидация полей."""
        if 'username' in data and 'email' in data:
            if data['username'] == data['email']:
                raise serializers.ValidationError(
                    'Username и email не должны совпадать'
                )
        return data

4. Обновление отдельных полей

class UserDetailView(generics.RetrieveUpdateDestroyAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes = [IsAuthenticated]
    
    # Кастомные action'ы для обновления отдельных полей
    @action(detail=True, methods=['post'], permission_classes=[IsAuthenticated])
    def change_email(self, request, pk=None):
        """Обновить только email с дополнительной проверкой."""
        user = self.get_object()
        new_email = request.data.get('email')
        
        if not new_email:
            return Response(
                {'email': 'Email обязателен'},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        if User.objects.filter(email=new_email).exists():
            return Response(
                {'email': 'Этот email уже зарегистрирован'},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        user.email = new_email
        user.email_verified = False  # Требуем подтверждение
        user.save()
        
        return Response(
            {'message': 'Email обновлён, требуется подтверждение'},
            status=status.HTTP_200_OK
        )
    
    @action(detail=True, methods=['post'], permission_classes=[IsAuthenticated])
    def change_password(self, request, pk=None):
        """Обновить пароль с проверкой старого."""
        user = self.get_object()
        old_password = request.data.get('old_password')
        new_password = request.data.get('new_password')
        
        if not old_password:
            return Response(
                {'old_password': 'Старый пароль обязателен'},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        if not user.check_password(old_password):
            return Response(
                {'old_password': 'Неверный пароль'},
                status=status.HTTP_401_UNAUTHORIZED
            )
        
        if len(new_password) < 8:
            return Response(
                {'new_password': 'Пароль должен быть не менее 8 символов'},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        user.set_password(new_password)
        user.save()
        
        return Response(
            {'message': 'Пароль успешно изменён'},
            status=status.HTTP_200_OK
        )

5. Обновление с оптимистичной блокировкой

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=100)
    email = models.EmailField()
    version = models.IntegerField(default=0)  # Версия для оптимистичной блокировки
    updated_at = models.DateTimeField(auto_now=True)

class UserUpdateSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'version']
    
    def validate_version(self, value):
        """Проверяем версию для оптимистичной блокировки."""
        if value != self.instance.version:
            raise serializers.ValidationError(
                'Данные были изменены. Обновите страницу и попробуйте снова'
            )
        return value
    
    def update(self, instance, validated_data):
        """Увеличиваем версию при обновлении."""
        validated_data.pop('version')  # Удаляем version из validated_data
        instance.version += 1
        return super().update(instance, validated_data)

class UserViewSet(viewsets.ModelViewSet):
    def partial_update(self, request, *args, **kwargs):
        # Требуем передачу текущей версии
        if 'version' not in request.data:
            return Response(
                {'version': 'Требуется передать текущую версию'},
                status=status.HTTP_400_BAD_REQUEST
            )
        return super().partial_update(request, *args, **kwargs)

6. Batch обновление

@action(detail=False, methods=['patch'])
def bulk_update(self, request):
    """Обновить несколько пользователей за раз."""
    updates = request.data.get('updates', [])
    
    if not isinstance(updates, list):
        return Response(
            {'error': 'updates должен быть списком'},
            status=status.HTTP_400_BAD_REQUEST
        )
    
    results = []
    errors = []
    
    for item in updates:
        try:
            user_id = item.get('id')
            user = User.objects.get(id=user_id)
            
            serializer = self.get_serializer(
                user,
                data=item,
                partial=True
            )
            serializer.is_valid(raise_exception=True)
            serializer.save()
            results.append(serializer.data)
        except Exception as e:
            errors.append({'id': item.get('id'), 'error': str(e)})
    
    return Response({
        'success': results,
        'errors': errors
    })

7. Обновление с историей изменений

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

class UserHistory(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='history')
    old_values = models.JSONField()  # Старые значения
    new_values = models.JSONField()  # Новые значения
    changed_by = models.ForeignKey(User, on_delete=models.SET_NULL, null=True)
    changed_at = models.DateTimeField(auto_now_add=True)

class UserViewSet(viewsets.ModelViewSet):
    def perform_update(self, serializer):
        """Сохраняем историю изменений."""
        old_values = {}
        for field in serializer.validated_data.keys():
            old_values[field] = str(getattr(serializer.instance, field))
        
        # Сохраняем старые значения
        serializer.save()
        
        # Записываем в историю
        UserHistory.objects.create(
            user=serializer.instance,
            old_values=old_values,
            new_values=serializer.validated_data,
            changed_by=self.request.user
        )

    @action(detail=True, methods=['get'])
    def history(self, request, pk=None):
        """Получить историю изменений пользователя."""
        user = self.get_object()
        history = user.history.order_by('-changed_at')
        
        return Response([
            {
                'timestamp': h.changed_at.isoformat(),
                'old_values': h.old_values,
                'new_values': h.new_values,
                'changed_by': h.changed_by.username if h.changed_by else 'system'
            }
            for h in history
        ])

8. Лучшие практики

• Используйте PATCH для частичного обновления — более идиоматично
• Валидируйте все входные данные — как на уровне сериализатора, так и в представлении
• Проверяйте права доступа — пользователи должны обновлять только свои данные
• Логируйте все изменения — для аудита и отладки
• Используйте оптимистичную блокировку — для защиты от race conditions
• Обновляйте атомарно — все или ничего
• Возвращайте полный объект — клиент должен знать финальное состояние
• Используйте HTTP статусы правильно: 200 OK (успех), 400 Bad Request (ошибка валидации), 401 Unauthorized (нет прав), 404 Not Found (объект не найден)
• Документируйте API — какие поля обязательны, какие необязательны
• Тестируйте обновления — unit и интеграционные тесты

Правильная реализация обновления в REST API критична для безопасности и удобства использования.