Как извлечь и обработать данные request в Django: полное руководство

def product_view(request):
product_id = request.GET.get('id')
category = request.GET.get('category', 'all') # 'all' — значение по умолчанию

# Дальнейшая логика работы с полученными параметрами
return render(request, 'product.html', {'product_id': product_id, 'category': category})

def search_products(request):
query = request.GET.get('q', '')
category = request.GET.get('category')
min_price = request.GET.get('min_price')
max_price = request.GET.get('max_price')

products = Product.objects.all()

if query:
products = products.filter(name__icontains=query)

if category:
products = products.filter(category=category)

if min_price:
products = products.filter(price__gte=float(min_price))

if max_price:
products = products.filter(price__lte=float(max_price))

return render(request, 'search_results.html', {'products': products, 'query': query})

# URL: /filter?color=red&color=blue&color=green
colors = request.GET.getlist('color') # ['red', 'blue', 'green']

def create_article(request):
if request.method == 'POST':
title = request.POST.get('title')
content = request.POST.get('content')

if title and content:
article = Article.objects.create(
title=title,
content=content,
author=request.user
)
return redirect('article_detail', article_id=article.id)
else:
error = "Title and content are required."
return render(request, 'create_article.html', {'error': error})

return render(request, 'create_article.html')

from .forms import ArticleForm

def create_article(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
article = form.save(commit=False)
article.author = request.user
article.save()
return redirect('article_detail', article_id=article.id)
else:
form = ArticleForm()

return render(request, 'create_article.html', {'form': form})

import json

def api_create_article(request):
if request.method == 'POST':
try:
data = json.loads(request.body)
title = data.get('title')
content = data.get('content')

# Дальнейшая обработка данных
except json.JSONDecodeError:
return JsonResponse({'error': 'Invalid JSON'}, status=400)

# Чтение cookie из request
def read_cookie_view(request):
user_preference = request.COOKIES.get('theme', 'light')
return render(request, 'page.html', {'theme': user_preference})

# Установка cookie в response
def set_cookie_view(request):
response = render(request, 'page.html')
response.set_cookie('theme', 'dark', max_age=31536000) # срок в секундах (1 год)
return response

# Удаление cookie
def delete_cookie_view(request):
response = render(request, 'page.html')
response.delete_cookie('theme')
return response

response.set_cookie(
'sensitive_data',
'value',
secure=True, # Только HTTPS
httponly=True, # Недоступно для JavaScript
samesite='Strict' # Отправляется только при переходе с того же домена
)

# Сохранение данных в сессии
def add_to_cart(request, product_id):
# Инициализация корзины, если она еще не создана
if 'cart' not in request.session:
request.session['cart'] = {}

cart = request.session['cart']

# Увеличение количества товара или добавление нового
if product_id in cart:
cart[product_id] += 1
else:
cart[product_id] = 1

# Маркировка сессии как измененной
request.session.modified = True

return redirect('cart')

# Чтение данных из сессии
def view_cart(request):
cart = request.session.get('cart', {})
products = []

for product_id, quantity in cart.items():
product = Product.objects.get(id=product_id)
products.append({
'product': product,
'quantity': quantity,
'total': product.price * quantity
})

return render(request, 'cart.html', {'products': products})

# Удаление данных из сессии
def clear_cart(request):
if 'cart' in request.session:
del request.session['cart']

return redirect('cart')

def header_inspector(request):
# Современный способ
user_agent = request.headers.get('User-Agent', '')
content_type = request.headers.get('Content-Type', '')

# Традиционный способ через META
referrer = request.META.get('HTTP_REFERER', '')
ip_address = request.META.get('REMOTE_ADDR', '')

context = {
'user_agent': user_agent,
'content_type': content_type,
'referrer': referrer,
'ip_address': ip_address,
}

return render(request, 'headers.html', context)

def api_endpoint(request):
auth_header = request.headers.get('Authorization', '')

if not auth_header.startswith('Bearer '):
return JsonResponse({'error': 'Invalid authorization header'}, status=401)

token = auth_header[7:] # Удаляем 'Bearer '

# Проверка токена
try:
payload = jwt.decode(token, settings.SECRET_KEY, algorithms=['HS256'])
user_id = payload['user_id']
user = User.objects.get(id=user_id)

# Продолжаем обработку запроса...

except (jwt.InvalidTokenError, User.DoesNotExist):
return JsonResponse({'error': 'Invalid token'}, status=401)

<!-- HTML форма (шаблон) -->
<form method="POST" enctype="multipart/form-data">
{% csrf_token %}
<input type="file" name="document">
<button type="submit">Загрузить</button>
</form>

# View-функция
def upload_file(request):
if request.method == 'POST':
if 'document' in request.FILES:
uploaded_file = request.FILES['document']

# Проверка типа и размера файла
if uploaded_file.content_type not in ['application/pdf', 'image/jpeg', 'image/png']:
return render(request, 'upload.html', {'error': 'Неподдерживаемый формат файла'})

if uploaded_file.size > 5 * 1024 * 1024: # 5MB
return render(request, 'upload.html', {'error': 'Файл слишком большой'})

# Сохранение файла
fs = FileSystemStorage()
filename = fs.save(uploaded_file.name, uploaded_file)
file_url = fs.url(filename)

return render(request, 'upload_success.html', {'file_url': file_url})

return render(request, 'upload.html')

from django import forms
from .models import Document

class DocumentForm(forms.ModelForm):
class Meta:
model = Document
fields = ('description', 'file')

def model_form_upload(request):
if request.method == 'POST':
form = DocumentForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return redirect('document_list')
else:
form = DocumentForm()
return render(request, 'upload.html', {'form': form})

import json
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt

@csrf_exempt # Только для API, не защищенных CSRF
def api_process_data(request):
if request.method == 'POST':
# Определяем формат входящих данных
content_type = request.headers.get('Content-Type', '').lower()

if 'application/json' in content_type:
try:
data = json.loads(request.body)
# Обработка JSON данных
response_data = {'message': 'JSON data processed', 'data': data}
return JsonResponse(response_data)
except json.JSONDecodeError:
return JsonResponse({'error': 'Invalid JSON'}, status=400)

elif 'application/xml' in content_type:
# Пример обработки XML с использованием библиотеки xml.etree.ElementTree
try:
import xml.etree.ElementTree as ET
tree = ET.fromstring(request.body)
# Обработка XML данных...
return JsonResponse({'message': 'XML data processed'})
except ET.ParseError:
return JsonResponse({'error': 'Invalid XML'}, status=400)

elif 'multipart/form-data' in content_type:
# Обработка формы с файлами
text_data = request.POST.get('text', '')
file_data = request.FILES.get('file')

if file_data:
# Обработка файла...
return JsonResponse({
'message': 'Form data processed',
'text': text_data,
'filename': file_data.name
})
else:
return JsonResponse({'error': 'No file uploaded'}, status=400)

else:
return JsonResponse({'error': 'Unsupported content type'}, status=415)

return JsonResponse({'error': 'Method not allowed'}, status=405)

from rest_framework.decorators import api_view, parser_classes
from rest_framework.response import Response
from rest_framework.parsers import JSONParser, MultiPartParser, FormParser

@api_view(['POST'])
@parser_classes([JSONParser, MultiPartParser, FormParser])
def process_mixed_data(request):
# DRF автоматически определяет формат и парсит request.data
data = request.data
files = request.FILES

# Теперь можно обрабатывать данные независимо от формата
response_data = {
'received_data': data,
'files_count': len(files)
}

return Response(response_data)

def handle_large_file(request):
if request.method == 'POST' and 'large_file' in request.FILES:
uploaded_file = request.FILES['large_file']

# Для больших файлов используем обработку по частям
with open('path/to/destination.file', 'wb+') as destination:
for chunk in uploaded_file.chunks():
destination.write(chunk)

return redirect('success')

return render(request, 'upload_large_file.html')

def process_user_data(request):
if request.method == 'POST':
name = request.POST.get('name', '')
age = request.POST.get('age', '')
email = request.POST.get('email', '')

# Базовая валидация
errors = {}

if not name or len(name) < 2:
errors['name'] = 'Имя должно содержать не менее 2 символов'

try:
age = int(age)
if age < 18 or age > 120:
errors['age'] = 'Возраст должен быть от 18 до 120 лет'
except (ValueError, TypeError):
errors['age'] = 'Возраст должен быть числом'

import re
email_pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
if not re.match(email_pattern, email):
errors['email'] = 'Введите корректный email-адрес'

if errors:
return render(request, 'form.html', {'errors': errors})

# Продолжаем обработку валидных данных
# ...

return render(request, 'form.html')

from django import forms
from django.core.validators import RegexValidator, MinValueValidator, MaxValueValidator

class UserProfileForm(forms.Form):
name = forms.CharField(
min_length=2, 
max_length=100,
validators=[
RegexValidator(r'^[a-zA-Zа-яА-Я\s]+$', 'Имя должно содержать только буквы')
]
)
age = forms.IntegerField(
validators=[
MinValueValidator(18, 'Возраст должен быть не менее 18 лет'),
MaxValueValidator(120, 'Возраст должен быть не более 120 лет')
]
)
email = forms.EmailField()
website = forms.URLField(required=False)
bio = forms.CharField(
widget=forms.Textarea,
max_length=500,
required=False
)

def profile_view(request):
if request.method == 'POST':
form = UserProfileForm(request.POST)
if form.is_valid():
# Данные валидны и доступны в form.cleaned_data
name = form.cleaned_data['name']
age = form.cleaned_data['age']
email = form.cleaned_data['email']

# Теперь безопасно использовать данные
# ...

return redirect('profile_success')
else:
form = UserProfileForm()

return render(request, 'profile_form.html', {'form': form})

# Пример защиты от Open Redirect
from django.utils.http import url_has_allowed_host_and_scheme

def redirect_to(request):
next_url = request.GET.get('next', '')

# Проверяем, что URL безопасен
if not url_has_allowed_host_and_scheme(
url=next_url,
allowed_hosts={request.get_host()},
require_https=True # Требуем HTTPS
):
next_url = 'default_page' # Перенаправляем на безопасную страницу

return redirect(next_url)

import bleach

def save_comment(request):
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
content = form.cleaned_data['content']

# Очищаем HTML, оставляя только безопасные теги
allowed_tags = ['p', 'b', 'i', 'u', 'a', 'ul', 'ol', 'li', 'br']
allowed_attributes = {'a': ['href', 'title']}

clean_content = bleach.clean(
content,
tags=allowed_tags,
attributes=allowed_attributes,
strip=True
)

# Теперь можно безопасно сохранить и отобразить контент
comment = Comment.objects.create(
user=request.user,
content=clean_content
)

return redirect('view_comment', comment_id=comment.id)

return render(request, 'comment_form.html', {'form': form})

from django.core.exceptions import SuspiciousOperation
import logging

logger = logging.getLogger('security')

def secure_endpoint(request):
try:
# Проверка подозрительных паттернов в данных
user_input = request.GET.get('q', '')

if '<script>' in user_input or 'javascript:' in user_input:
# Логируем попытку XSS
logger.warning(
'Possible XSS attack detected',
extra={
'ip': request.META.get('REMOTE_ADDR'),
'user_id': request.user.id if request.user.is_authenticated else None,
'input': user_input
}
)

# В продакшене можно вернуть 400 без деталей
raise SuspiciousOperation("Invalid input detected")

# Продолжаем нормальную обработку...
return HttpResponse("OK")

except SuspiciousOperation:
# В Django >= 1.8 это автоматически возвращает 400 Bad Request
# Можно кастомизировать ответ при необходимости
return HttpResponseBadRequest("Bad Request")