Перейти к содержимому

Django rest framework что это

  • автор:

Django REST Framework — что это такое

Этим видео мы открываем серию занятий по очень популярному пакету Django REST Framework (сокращенно – DRF). Как вы уже догадались из названия – это дополнение к известному фреймворку Django, о котором мы с вами уже говорили. Если вы с ним не знакомы, то советую вначале посмотреть этот плейлист:

Так что же делает DRF и зачем он нужен? Сейчас, современным web-сайтам приходится взаимодействовать не только с браузерами клиентов, где отображаются соответствующие HTML-документы, но и с другими произвольными конечными устройствами. Часто это смартфоны, работающие под различные ОС (например, Android, iOS) и программы, написанные, как правило, на языке Java, также должны получать доступ к данным сайта и уметь с ним взаимодействовать. Например, у многих установлены программы по online-банкингу или программы от сотового оператора, где можно оперативно посмотреть информацию и выполнить определенные действия.

Как раз здесь происходит взаимодействие с сервером по определенному программному протоколу. И аббревиатура

REST (от англ. Representational State Transfer)

в названии DRF – как раз и следует интерпретировать, как архитектурный стиль взаимодействия между сервером и различными клиентами. Звучит несколько мудрено, но по-простому – это описание способа взаимодействия между сервером и любым конечным устройством, подключенным к сети Интернет.

Как реализуется это взаимодействие? На стороне сервера создается специальный программный интерфейс, который сокращенно называется:

API (от англ. Application Programming Interface)

И Django REST Framework как раз обеспечивает взаимодействие любого конечного устройства через API с сайтом на сервере. То есть, DRF, фактически, это инструмент создания API для нашего сайта с целью удаленного взаимодействия с ним. Например, мы хотим в программе на Java, которая запущена на смартфоне, отобразить список статей сайта. Для этого из java-программы отправляется обычный GET-запрос к сайту, скажем, такой:

Сайт формирует данные по этому запросу и возвращает их клиенту (смартфону), например, в JSON-формате:

{"pages": [ {"title": "Django - what is that", "url": "https://proproprogs.ru/django/django-chto-eto-takoe-poryadok-ustanovki"}, {"title": "Model MTV", "url": "https://proproprogs.ru/django/model-mtv-marshrutizaciya-funkcii-predstavleniya"}, {"title": "Request, redirect", "url": "https://proproprogs.ru/django/marshrutizaciya-perenapravleniya"} ] }

То есть, возвращается не HTML-документ, а «сырые» данные в формате JSON. Как раз они и формируются с помощью Django REST Framework. Затем, формат JSON обрабатывается Java-программой на смартфоне и отображаются данные уже в приложении клиента.

  • создание, чтение, изменение и удаление данных (сокращенно это называется CRUD);
  • проверку корректности передаваемых данных от клиента и защиту от возможных хакерских атак;
  • авторизацию и регистрацию пользователей;
  • права доступа к данным через API.

Архитектура Django REST Framework

Теперь, когда мы с вами в целом разобрались для чего нужен Django REST Framework, давайте посмотрим на его общую архитектуру, из которой хорошо виден принцип работы DRF. Вначале приходит запрос от клиента, который обрабатывается маршрутизатором фреймворка Django. Например, такой: https://proproprogs.ru/api/v1/listpages/ Далее, с этим запросом связано одно из представлений, которое реализует API-сайта. То есть, представление для API уже создается средствами DRF. Задачей представления является обработка запроса и отправка результата пользователю. Так как для обработки необходимо сформировать некоторые данные, как правило, в формате JSON, то для этого управление передается специальному объекту – сериализатору. Сериализаторы – это «сердце» Django REST Framework. Именно они формируют данные для ответа на API-запросы, а также выполняют парсинг входной информации. Например, сериализатор может взять данные из таблиц БД и вернуть JSON-строку узлу, который отправил запрос. Или, сериализатор может удалить или изменить данные в таблицах БД по определенному запросу. На последующих занятиях мы подробно познакомимся с созданием представлений, сериализаторов, а также управлением правами доступа и задачами авторизации и аутентификации пользователей. Поехали! Курс по Django: https://stepik.org/a/183363

Разработка Web API на Django с помощью Django REST framework: от создания моделей до тестирования

Django REST framework (DRF) — это мощный и гибкий инструмент для создания Web API на основе Django. Он предоставляет удобные средства для создания RESTful API, поддерживает аутентификацию, авторизацию, сериализацию, валидацию и другие функции.

В этой статье мы рассмотрим, как использовать Django REST framework для создания Web API на базе Django.

Шаг 1: Установка Django REST framework

Первым шагом является установка Django REST framework. Вы можете установить его с помощью pip:

pip install djangorestframework
Шаг 2: Создание проекта Django

Для создания проекта Django используйте команду:

django-admin startproject myproject
Шаг 3: Создание приложения Django

Создайте приложение Django с помощью команды:

python manage.py startapp myapp
Шаг 4: Настройка Django REST framework
INSTALLED_APPS = [ . 'rest_framework', 'myapp', ]

Добавьте REST framework middleware в MIDDLEWARE в файле settings.py:

MIDDLEWARE = [ . 'rest_framework.middleware.AuthenticationMiddleware', 'rest_framework.middleware.AuthorizationMiddleware', ]
Шаг 5: Создание модели Django

Определите модель Django в файле models.py вашего приложения:

from django.db import models class Product(models.Model): name = models.CharField(max_length=100) description = models.TextField() price = models.DecimalField(max_digits=10, decimal_places=2) created_at = models.DateTimeField(auto_now_add=True) updated_at = models.DateTimeField(auto_now=True) def __str__(self): return self.name
Шаг 6: Создание сериализатора Django REST framework

Определите сериализатор Django REST framework в файле serializers.py вашего приложения:

from rest_framework import serializers from myapp.models import Product class ProductSerializer(serializers.ModelSerializer): class Meta: model = Product fields = ['id', 'name', 'description', 'price', 'created_at', 'updated_at']
Шаг 7: Создание представления Django REST framework

Определите представление Django REST framework в файле views.py вашего приложения:

from rest_framework import generics from myapp.models import Product from myapp.serializers import ProductSerializer class ProductList(generics.ListCreateAPIView): queryset = Product.objects.all() serializer_class = ProductSerializer class ProductDetail(generics.RetrieveUpdateDestroyAPIView): queryset = Product.objects.all() serializer_class = Product
Шаг 8: Настройка маршрутов Django REST framework

Определите маршруты Django REST framework в файле urls.py вашего приложения:

from django.urls import path from myapp.views import ProductList, ProductDetail urlpatterns = [ path('products/', ProductList.as_view(), name='product-list'), path('products//', ProductDetail.as_view(), name='product-detail'), ]
Шаг 9: Запуск приложения Django

Запустите приложение Django с помощью команды:

python manage.py runserver
Шаг 10: Тестирование Web API

Откройте веб-браузер и перейдите по адресу http://127.0.0.1:8000/products/. Вы должны увидеть список всех продуктов.

Чтобы создать новый продукт, отправьте POST-запрос на http://127.0.0.1:8000/products/ с данными в формате JSON:

Чтобы получить детали конкретного продукта, отправьте GET-запрос на http://127.0.0.1:8000/products/1/, где 1 — идентификатор продукта.

Чтобы обновить продукт, отправьте PUT-запрос на http://127.0.0.1:8000/products/1/ с данными в формате JSON:

Чтобы удалить продукт, отправьте DELETE-запрос на http://127.0.0.1:8000/products/1/.

В этой статье мы рассмотрели, как использовать Django REST framework для создания Web API на базе Django. Django REST framework предоставляет удобные средства для создания RESTful API, поддерживает аутентификацию, авторизацию, сериализацию, валидацию и другие функции. С его помощью вы можете быстро и легко создавать мощные и гибкие Web API на базе Django.

1. Знакомство с REST

Термин REST API расшифровывается как Representational State Transfer Application Programming Interface. Следовательно, RESTful API — это программный интерфейс приложения, соответствующий ограничениям архитектурного стиля REST.

REST — не протокол и не стандарт. Это, как уже было сказано, архитектурное ограничение. Чтобы API считался RESTful, он должен соответствовать следующим критериям.

  1. Единый интерфейс.
    Единый интерфейс (uniform interface) строится вокруг ресурсов с уникальными идентификаторами и уникальными URL, а каждая страница реализовывает какие-либо из HTTP-методов — GET, POST, DELETE или UPDATE— все они отвечают за различные манипуляции конкретным ресурсом.
  2. Архитектура “Клиент-Сервер”
    Сервер анализирует запрос клиента и отправляет ему ответ. Получив ответ от сервера, клиент определяет, как именно информация отобразится у конечных пользователей.
  3. Нестационарные запросы
    Нестационарность (stateless) означает, что каждый HTTP-запрос полностью изолирован. Сервер не полагается на информацию из предыдущих запросов — клиент отправляет HTTP-запрос, включающий сразу всю необходимую ему информацию. Сервер не хранит контекста между запросами, каждый запрос содержит всю необходимую информацию.

Благодаря вышеперечисленным архитектурным правилам REST API масштабируемый, переносимый и гибкий.

2. Что такое Django REST Framework?

Django — масштабируемый полнофункциональный веб-фреймворк, написанный на Python. Django берет на себя все хлопоты, зачастую связанные с веб-разработкой, такие как безопасность и доступ к базам данных.

Существует множество библиотек для Django, расширяющих его функционал. Одна из них, о которой мы поговорим сегодня, — это Django REST Framework или DRF, которая позволяет сериализовать данные из Django ORM через REST API.

Сериализация — это преобразование таблиц из базы данных в формат JSON.

Руководство написано для новичков, прошлый опыт работы с фреймворком Django не предполагается, так как вы многому научитесь прямо сейчас. Кроме того, в статье не будет обширного описания технических нюансов каждой операции. Рассматривайте руководство в качестве упражнения.

Давайте создадим сайт бронирования отелей! Исходный код и справка доступны на GitHub.

3. Установка Django

Прежде чем приступить непосредственно к работе с REST API, сделаем краткий экскурс в Django.

3.1. Создание виртуальной среды

$ virtualenv venv
$ source venv/bin/activate

3.2. Установка зависимостей

$ pip install djangorestframework
$ pip install django

3.3. Начало проекта

$ django-admin startproject hotel_reservation
$ cd demo/

3.4. Изменение директории

$ mv hotel_reservation/manage.py .
$ mv hotel_reservation/hotel_reservation/* hotel_reservation/
$ rm -r hotel_reservation/hotel_reservation/

3.5. Запуск сервера

$ python manage.py runserver

Теперь перейдите по адресу http://127.0.0.1:8000/ в браузере. Если все прошло успешно, то вы увидите следующую страницу:

3.6. Создание приложения

Приложения в Django — это независимые многократно используемые компоненты. Создадим приложение hotel_app .

$ django-admin startapp hotel_app

3.7. Список приложений в проекте

Чтобы подключить к проекту hotel_reservation приложения hotel_app и rest_framework , необходимо отредактировать файл results/settings.py , указав эти приложения в списке INSTALLED_APPS :

INSTALLED_APPS = [ 
'django.contrib.admin', 
'django.contrib.auth', 
'django.contrib.contenttypes', 
'django.contrib.sessions', 
'django.contrib.messages', 
'django.contrib.staticfiles', 
 'hotel_app' 
'rest_framework'
]

3.8. Миграции

Теперь нужно выполнить Django-миграции — это способ Django распространять в схему базы данных все изменения, вносимые в модели, такие как добавление поля, удаление модели. Выполняйте эту команду каждый раз, когда модель или база данных сколько-нибудь меняются:

$ python manage.py migrate

3.9. Административная панель

Django поставляется со встроенной панелью администратора, что позволяет создать суперпользователя с помощью одной команды. Заполните форму — появится учетная запись администратора:

$ python manage.py createsuperuser

Снова выполните миграции, авторизуйтесь.

3.10. Создание модели

Django ORM абстрагирует базу данных, позволяя легко запрашивать данные и манипулировать ими через объектно-ориентированное отображение, называемое моделью. Django ORM заставляет писать код согласно паттерну MVC (Model View Controller), который станет интуитивно понятным для вас после прохождения кривой обучения.

hotel_app/models.py :

from datetime import timedelta, datetime
from django.db import models
from datetime import datetime

class Guest(models.Model): 
name = models.CharField(max_length=20) 
age = models.IntegerField(default=20) 
phone = models.CharField(max_length=20) 
email = models.CharField(max_length=30)
 
def __str__(self) -> str: 
return self.name 


class Hotel(models.Model): 
name = models.CharField(max_length=20) 
location = models.CharField(max_length=50) 
phone = models.CharField(max_length=20) 
email = models.CharField(max_length=30)
 
def __str__(self) -> str: 
return self.name


class Room(models.Model): 
room_no = models.IntegerField(default=101) 
price = models.FloatField(default=1000.0) 
hotel = models.ForeignKey(Hotel, on_delete=models.CASCADE) 
is_booked = models.BooleanField(default=False)
 
def __str__(self) -> str: 
return str(self.room_no)
 
def hotel_name(self) -> str: 
return self.hotel


class Booking(models.Model): 
guest = models.ForeignKey(Guest, on_delete=models.CASCADE) 
hotel = models.ForeignKey(Hotel, on_delete=models.CASCADE) 
room = models.ForeignKey(Room, on_delete=models.CASCADE) 
num_of_guest = models.IntegerField(default=1) 
checkin_date = models.DateField(default=datetime.now) 
checkout_date = models.DateField(default=datetime.now) 
is_checkout = models.BooleanField(default=False)
 
def __str__(self) -> str: 
return self.guest.name
 
def hotel_name(self) -> str: 
return self.hotel.hotel
 
def charge(self) -> float: 
return self.is_checkout* \ 
(self.checkout_date - self.checkin_date + timedelta(1)).days* \ 
self.room.price

Мы создали модель, хранящую имя студента и его оценки. Метод __str__ определяет имя объекта, отображаемое в браузере. Если пропустить определение данного метода, то вы увидите в панели администратора объект под названием .

3.11. Не забывайте о миграциях!

Теперь, когда изменения уже внесены в модель, настало время выполнить миграции.

$ python manage.py makemigrations
$ python manage.py migrateviews.

3.12. Добавление приложения в админ-панель

Во встроенное приложение административной панели можно добавить созданную ранее пользовательскую модель.

hotel_app/admin.py :

from django.contrib import admin
from .models import Guest, Hotel, Room , Bookingadmin.site.register(Guest)
admin.site.register(Hotel)
admin.site.register(Room)
admin.site.register(Booking)

Теперь мы завершили ту общую часть разработки веб-приложения, которая относится к фреймворку Django. Настало время приступить к проектированию REST API.

4. Написание Django REST API

Структура директорий проекта:

$ tree -I 'venv'
.
├── db.sqlite3
├── hotel_app
│ ├── __init__.py
│ ├── __pycache__
│ ├── admin.py
│ ├── apps.py
│ ├── models.py
| ├── serializer.py
│ ├── tests.py
│ ├── urls.py
│ └── views.py
├── hotel_reservation
│ ├── __init__.py
│ ├── asgi.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
└── manage.py

Добавим в проект файлы urls.py и serializers.py . Вот новый список файлов.

4.1. Сериализатор

Сериализация — процесс перевода структуры данных в последовательность байтов. Она используется для передачи объектов по сети и для сохранения их в файлы (Википедия).

hotel_app/serializers.py :

from rest_framework import fields, serializers
from .models import Guest, Hotel, Room , Booking 


class GuestSerializer(serializers.HyperlinkedModelSerializer): 
class Meta: 
model = Guest 
fields = ("name", "age", "phone", "email")


class HotelSerializer(serializers.ModelSerializer): 
class Meta: 
model = Hotel 
fields = ("name", "location", "phone", "email")


class RoomSerializer(serializers.ModelSerializer): 
class Meta: 
model = Room 
fields = ("room_no", "price", "hotel", "is_booked")


class BookingSerializer(serializers.ModelSerializer): 
guest = GuestSerializer 
hotel = HotelSerializer 
room = RoomSerializer 
class Meta: 
model = Booking 
fields =("guest", "hotel", "room", "checkin_date", "checkout_date", "charge",)

Сериализаторы определяют, как именно и какие данные отобразит представление API. При запросе по REST API к экземпляру модели Hotel мы получим список следующих полей, взятых из самой модели при помощи сериализатора:

 “name” : “”, 
“location” : “”, 
“phone” : “”, 
“email” : ””,
>

4.2. Представления

Файл представления определяет то, как сериализованные объекты отображаются пользователю.

from rest_framework import status
from rest_framework.response import Response
from rest_framework.decorators import api_view

from .models import Guest, Hotel, Room , Booking 
from .serializer import GuestSerializer ,HotelSerializer, RoomSerializer, BookingSerializer 

from collections import namedtuple


nt = namedtuple("object", ["model", "serializers"])
pattern = "guest" : nt(Guest, GuestSerializer), 
"hotel" : nt(Hotel, HotelSerializer), 
"room" : nt(Room, RoomSerializer), 
"booking": nt(Booking, BookingSerializer),
>

@api_view(["GET", "POST"])
def ListView(request, api_name): 
object = pattern.get(api_name, None) 
if object == None: 
return Response( 
data = "Invalid URL", 
status = status.HTTP_404_NOT_FOUND, 
) 
if request.method == "GET": 
object_list = object.model.objects.all() 
serializers = object.serializers(object_list, many=True) 
return Response(serializers.data)
 
if request.method == "POST": 
data = request.data 
serializers = object.serializers(data=data) 
 
if not serializers.is_valid(): 
return Response( 
data = serializers.error, 
status = status.HTTP_404_NOT_FOUND 
) 
serializers.save() 
return Response( 
data = serializers.error, 
status = status.HTTP_201_CREATED 
)

Вышеописанное представление возвращает результат для URL-параметра api_name при его соответствии одному из следующих значений: guest, hotel, room или booking . В противном случае представление отправляет клиенту сообщение Invalid URL .

4.3. URL: ссылки на ресурсы

hotel_app/urls.py :

from django.urls import re_path
from .views import ListViewurlpatterns = [ 
re_path(r"^(?P[a-z]+)", ListView, name='hotel-objects'),
]

hotel_reservation/urls.py :

from django.contrib import admin
from django.urls import path, includeurlpatterns = [ 
path(‘admin/’, admin.site.urls), 
path(‘hotel-app’, include(‘hotel_app.urls’))
]

Таким образом определяется базовый URL-путь для API: http://127.0.0.1:8000/hotel-app/.

Перейдя по данной ссылке, вы получите доступ ко всем ранее определенным “разделам” REST API проекта:

  • guest : http://127.0.0.1:8000/hotel-app/guest/.
  • hotel : http://127.0.0.1:8000/hotel-app/hotel/.
  • room : http://127.0.0.1:8000/hotel-app/room/.
  • booking : http://127.0.0.1:8000/hotel-app/booking/.

При попытке запросить какое-либо иное API браузер получит от сервера сообщение об ошибке, так как в приложении бронирования отеля существуют только эти четыре вида API.

5. Выводы

Мы успешно реализовали пользовательский интерфейс отправки запросов HTTP-методами GET и POST. API готов, к нему можно получить доступ по соответствующей ссылке. Весь исходный код руководства доступен на GitHub.

  • 4 совета Python Django разработчику
  • Галерея лучших модулей Python
  • Python Django: контактная форма с автоматической отправкой Email

Создаем API блога на Django REST Framefork

API-сервисы позволяют приложениям общаться с другими приложения с помощью данных, передаваемых в формате JSON. Достаточно создать и использовать его данные из любого API-клиента или фронтенд-приложения.

Django REST Framework — это набор инструментов для создания REST API с помощью Django. В этом руководстве рассмотрим, как правильно его использовать. Создадим эндпоинты(точки доступа к ресурсам) для пользователей, постов в блоге, комментариев и категорий.

Также рассмотрим аутентификацию, чтобы только залогиненный пользователь мог изменять данные приложения.

Вот чему вы научитесь:

  • Добавлять новые и существующие модели Django в API.
  • Сериализовать модели с помощью встроенных сериализаторов для распространенных API-паттернов.
  • Создавать представления и URL-паттерны.
  • Создавать отношения многие-к-одному и многие-ко-многим.
  • Аутентифицировать пользовательские действия.
  • Использовать созданный API Django REST Framework.

Требования

У вас в системе должен быть установлен Python 3, желательно 3.8. Также понадобится опыт работы с REST API. Вы должны быть знакомы с реляционными базами данными, включая основные и внешние ключи, модели баз данных, миграции, а также отношения многие-к-одному и многие-ко-многим.

Наконец, потребуется опыт работы с Python и Django.

Настройка проекта

Для создания нового API-проекта для начала создайте виртуальную среду Python в своей рабочей директории. Для этого запустите следующую команду в терминале:

python3 -m venv env source env/bin/activate

В Windows это будет source env\Scripts\activate .

Не забывайте запускать все команды из этого руководства в виртуальной среде. Убедиться в том, что она активирована можно благодаря надписи ( env ) в начале строки приглашения к вводу в терминале.

Чтобы деактивировать среду, введите deactivate .

После этого установите Django и REST Framework в среду:

pip install django==3.1.7 djangorestframework==3.12.4

Создайте новый проект «blog» и новое приложение «api»:

django-admin startproject blog cd blog django-admin startapp api

Создание нового API-проекта

Из корневой директории «blog» (там где находится файл «manage.py»), синхронизируйте базу данных. Это запустит миграции для admin , auth , contenttypes и sessions .

python manage.py migrate

Вам также понадобится пользователь admin для взаимодействия с панелью управления Django и API. Из терминала запустите следующее:

python manage.py createsuperuser --email admin@example.com --username admin

Установите любой пароль (у него должно быть как минимум 8 символов). Если вы введете слишком простой пароль, то можете получить ошибку.

Для настройки, добавьте rest_framework и api в файл конфигурации (blog/blog/settings.py):

 
INSTALLED_APPS = [ . 'rest_framework', 'api.apps.ApiConfig', ]


Добавление ApiConfig позволит добавлять параметры конфигурации в приложение. Другие настройки для этого руководства не потребуются.


Наконец, запустите локальный сервер с помощью команды python manage.py runserver .


Перейдите по ссылке http://127.0.0.1:8000/admin и войдите в админ-панель сайта. Нажмите на «Users», чтобы увидеть пользователя и добавить новых при необходимости.


админ-панель сайта


Создание API для пользователей


Теперь с пользователем «admin» можно переходить к созданию самого API. Это предоставит доступ только для чтения списку пользователей из списка API-эндпоинтов.


Сериализатор для User 


REST Framework Django использует сериализаторы, чтобы переводить наборы запросов и экземпляры моделей в JSON-данные. Сериализация также определяет, какие данные вернет API в ответ на запрос клиента.


Пользователи Django создаются из модели User , которая определена в django.contrib.auth . Для создания сериализатора для модели добавьте следующее в blog/api/serializers.py (файл нужно создать):


 
from rest_framework import serializers from django.contrib.auth.models import User class UserSerializer(serializers.ModelSerializer): class Meta: model = User fields = ['id', 'username']


По примеру импортируйте модель User из Django вместе с набором сериализаторов из REST Framework Django.


Теперь создайте класс UserSerializer , который должен наследоваться от класса ModelSerializer .


Определите модель, которая должна ассоциироваться с сериализатором (model = User). Массив fields определяет, какие поля модели должны быть включены. Например, можно добавлять поля first_name и last_name .


Класс ModelSerializer генерирует поля сериализатора, которые основаны на соответствующих свойствах модели. Это значит, что не нужно вручную указывать все атрибуты для поля сериализации, поскольку они вытягиваются напрямую из модели.


Этот сериализатор также создает простые методы create() и update() . При необходимости их можно переписать.


Ознакомиться подробнее с работой ModelSerializer можно на официальном сайте.


Представления для User


Есть несколько способов создавать представления в REST Framework Django. Чтобы получить возможность повторного использования кода и избегать повторений, используйте классовые представления.


REST Framework предоставляет несколько обобщенных представлений, основанных на классе APIView . Они представляют собой самые распространенные паттерны.


Например, ListAPIView используется для эндпоинтов с доступом только для чтения. Он предоставляет метод-обработчик get . ListCreateAPIView используется для эндпоинтов с разрешением чтения-записи, а также обработчики get и post .


Для создания эндпоинта только для чтения, который возвращал бы список пользователей, добавьте следующее в blog/api/views.py:


 
from rest_framework import generics from . import serializers from django.contrib.auth.models import User class UserList(generics.ListAPIView): queryset = User.objects.all() serializer_class = serializers.UserSerializer class UserDetail(generics.RetrieveAPIView): queryset = User.objects.all() serializer_class = serializers.UserSerializer


В первую очередь здесь импортируется generics коллекция представлений, а также модель User и UserSerialized из предыдущего шага. Представление UserList предоставляет доступ только для чтения (через get ) к списку пользователей, а UserDetails — к одному пользователю.


Названия представлений должны быть в следующем формате: List и Details для коллекции объектов и одного объекта соответственно.


Для каждого представления переменная queryset содержит коллекцию экземпляров модели, которую возвращает User.objects.all() . Значением serializer_class должно быть UserSerializer , который и сериализует данные модели User .


Пути к эндпоинтам будут настроены на следующем шаге.


URL-паттерны


С моделью, сериализатором и набором представлений для User финальным шагом будет создание эндпоинтов (которые в Django называются URL-паттернами) для каждого представления.


В первую очередь добавьте следующее в blog/api/urls.py (этот файл тоже нужно создать):


 
from django.urls import path from rest_framework.urlpatterns import format_suffix_patterns from . import views urlpatterns = [ path('users/', views.UserList.as_view()), path('users//', views.UserDetail.as_view()), ] urlpatterns = format_suffix_patterns(urlpatterns)


Здесь импортируется функция path и также коллекция представлений приложения api .


Функция path создает элемент, который Django использует для показа страницы приложения. Для этого Django в первую очередь ищет нужный элемент с соответствующим URL (например, users/ ) для запрошенного пользователем. После этого он импортирует и вызывает соответствующее представление (то есть, UserList )


Последовательность указывает на целочисленное значение, которое является основным ключом ( pk ). Django захватывает эту часть URL и отправляет в представление в виде аргумента-ключевого слова.


В этом случае основным ключом для User является поле id , поэтому http://127.0.0.1:8000/users/1 вернет id со значением 1 .


Прежде чем можно будет взаимодействовать с этими URL-паттернами (и теми, которые будут созданы позже) их нужно добавить в проект. Добавьте следующее в blog/blog/urls.py:


 
from django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('', include('api.urls')), ]


Чтобы убедиться, что все элементы работают корректно, перейдите по ссылке http://127.0.0.1:8000/users, чтобы увидеть список пользователей приложения.


Django REST framework User List




В этом руководстве используется графическое представление API из Django REST Framework для демонстрации эндпоинтов. Интерфейс предоставляет элементы аутентификации и формы, имитирующие фронтенд-клиент. Для тестирования API также можно использовать cURL или httpie.




Обратите внимание на то, что значение пользователя admin равно 1 . Можете перейти к нему, открыв для этого http://127.0.0.1:8000/users/1.


Django REST framework User Detail


В итоге класс модели Django сериализуется с помощью UserSerializaer . Он предоставляет данные представлениям UserList и UserDetail , доступ к которым можно получить с помощью паттернов users/ и users/ .


Создание API для Post


После базовой настройки можно приступать к созданию полноценного API для блога с эндпоинтами для постов, комментариев и категорий. Начнем с API для Post.


Модель Post


В blog/api/models.py создайте модель Post , которая наследуется от класса Model из Django и определите ее поля:


 
from django.db import models class Post(models.Model): created = models.DateTimeField(auto_now_add=True) title = models.CharField(max_length=100, blank=True, default='') body = models.TextField(blank=True, default='') owner = models.ForeignKey('auth.User', related_name='posts', on_delete=models.CASCADE) class Meta: ordering = ['created']


Типы полей соответствуют таковым в реляционных базах данные. Можете ознакомиться со страницей Models на официальном сайте фреймворка.


Обратите внимание на то, что тип ForeignKey создает отношение многие-к-одному между текущей моделью и моделью, указанной в первом аргументе ( auth.User — то есть, модель User , с которой вы работаете).


В этом случае пользователь может иметь много статей, но у поста может быть всего один владелец. Поле owner может быть использовано во фронтенд-приложении для получения пользователя и отображения его имени в качестве автора поста.


Аргумент related_name позволяет задать другое имя доступа к текущей модели ( posts ) вместо стандартного ( post_set ). Список постов будет добавлен в сериализатор User на следующем шаге для завершения отношения многие-к-одному.


Каждый раз при обновлении модели запускайте следующие команды для обновления базы данных:


python manage.py makemigrations api python manage.py migrate


Поскольку мы работаем с моделями Django, таким как User , посты можно изменить из административной панели Django, зарегистрировав ее в blog/api/admin.py:


 
from django.contrib import admin from .models import Post admin.site.register(Post)


Позже их можно будет создавать и через графическое представление API.


Перейдите на http://127.0.0.1:8000/admin, кликните на Posts и добавьте новые посты. Вы заметите, что поля title и body в форме соответствуют типам CharField и TextField из модели Post .


Также можно выбрать owner среди существующих пользователей. При создании поста в API пользователя выбирать не нужно. Owner будет задан автоматически на основе данных залогиненного пользователя. Это настроим в следующем шаге.


Сериализатор Post


Чтобы добавить модель Post в API, нужно повторить шаги добавления модели User .


Сначала нужно сериализовать данные модели Post . В blog/api/serializers.py добавьте следующее:


 
from rest_framework import serializers from django.contrib.auth.models import User from .models import Post class PostSerializer(serializers.ModelSerializer): owner = serializers.ReadOnlyField(source='owner.username') class Meta: model = Post fields = ['id', 'title', 'body', 'owner'] class UserSerializer(serializers.ModelSerializer): posts = serializers.PrimaryKeyRelatedField(many=True, read_only=True) class Meta: model = User fields = ['id', 'username', 'posts']


Импортируйте модель Post из приложения api и создайте PostSerializer , который будет наследоваться от класса ModelSerializer . Задайте модель и поля, которые будут использоваться сериализатором.


ReadOnlyField — это класс, возвращающий данные без изменения. В этом случае он используется для возвращения поля username вместо стандартного id .


Дальше добавьте поле posts в UserSerializer . Отношение многие-к-одному между постами и пользователями определено моделью Post в прошлом шаге. Название поля ( posts ) должно быть равным аргументу related_field поля Post.owner . Замените posts на post_set (значение по умолчанию), если вы не задали значение related_field в прошлом шаге.


PrimaryKeyRelatedField представляет список публикаций в этом отношении многие-к-одному ( many=True указывает на то, что постов может быть больше чем один).


Если не задать read_only=True поле posts будет иметь права записи по умолчанию. Это значит, что будет возможность вручную задавать список статей, принадлежащих пользователю при его создании. Вряд ли это желаемое поведение.


Перейдите по ссылке http://127.0.0.1:8000/users, чтобы увидеть поле posts каждого пользователя.




Обратите внимание на то, что список posts — это, по сути, список id. Вместо этого можно возвращать список URL с помощью HyperLinkModelSerializer .




Представления Post


Следующий шаг — создать набор представлений для Post API. Добавьте следующее в blog/api/views.py:


 
. from .models import Post . class PostList(generics.ListCreateAPIView): queryset = Post.objects.all() serializer_class = serializers.PostSerializer def perform_create(self, serializer): serializer.save(owner=self.request.user) class PostDetail(generics.RetrieveUpdateDestroyAPIView): queryset = Post.objects.all() serializer_class = serializers.PostSerializer


ListCreateAPIView и RetrieveUpdateDestroyAPIView предоставляют самые распространенные обработчики API-методов: get и post для списка ( ListCreateAPIView ) и get , update и delete для одной сущности ( RetrieveUpdateDestroyAPIView ).


Также нужно перезаписать функцию по умолчанию perform_create , чтобы задать поле owner текущего пользователя (значение self.request.user ).


URL-паттерны Post


Чтобы закончить с эндпоинтами для Post API создайте URL-паттерны Post . Добавьте следующее в массив urlpatterns в blog/api/urls.py:


 
urlpatterns = [ . path('posts/', views.PostList.as_view()), path('posts//', views.PostDetail.as_view()), ]


Объединение представлений с этими URL-паттернами создает эндпоинты:


    

  • get posts/ ,
    • 

  • post posts/ ,
    • 

  • get posts// ,
    • 

  • put posts//
    • 

  • и delete posts// .
    • 



Чтобы протестировать их, перейдите на http://127.0.0.1:8000/posts и создайте публикации. Я взял несколько статей из Медиума.


Перейдите на один пост (например, http://127.0.0.1:8000/posts/1 и нажмите DELETE. Чтобы поменять название поста, обновите поле «title» и нажмите PUT.


Django REST framework Post Detail


После этого перейдите на http://127.0.0.1:8000/posts, чтобы увидеть список существующих публикаций или создать новый. Убедитесь, что вы залогинены, потому что при создании поста его автор создается на основе данных текущего пользователя.


Django REST framework Post List


Настройка разрешений


Для удобства добавим кнопку «Log in» в графическое представление API с помощью следующего кода в blog/urls.py:


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


Теперь можно заходить под разными аккаунтами, чтобы проверять работу разрешений и изменять посты через интерфейс.


Сейчас можно создать пост, будучи зарегистрированным, но для удаления или изменения данных этого не требуется — даже если пост вам не принадлежит. Попробуйте зайти под другим аккаунтом, и вы сможете удалить посты, принадлежащие admin .


Чтобы аутентифицировать пользователя и быть уверенным в том, что только владелец поста может обновлять и удалять его, нужно добавить разрешения.


Начните с этого кода в blog/api/permisisions.api (файл необходимо создать):


 
from rest_framework import permissions class IsOwnerOrReadOnly(permissions.BasePermission): def has_object_permission(self, request, view, obj): if request.method in permissions.SAFE_METHODS: return True return obj.owner == request.user


Разрешение IsOwnerOrReadOnly проверяет, является ли пользователь владельцем этого объекта. Таким образом только при этом условии можно будет обновлять или удалять пост. Не-владельцы смогут получать пост, потому что это действие только для чтения.


Также есть встроенное разрешение IsAuthenticatedOrReadOnly . С ним любом аутентифицированный пользователь может выполнять любой запрос, а остальные — только на чтение.


Добавьте эти разрешения в представления Post :


 
from rest_framework import generics, permissions . from .serializers import PostSerializer from .permissions import IsOwnerOrReadOnly . class PostList(generics.ListCreateAPIView): queryset = Post.objects.all() serializer_class = PostSerializer permission_classes = [permissions.IsAuthenticatedOrReadOnly] def perform_create(self, serializer): serializer.save(owner=self.request.user) class PostDetail(generics.RetrieveUpdateDestroyAPIView): queryset = Post.objects.all() serializer_class = PostSerializer permission_classes = [permissions.IsAuthenticatedOrReadOnly, IsOwnerOrReadOnly]


Представлению PostList требуется разрешение IsAuthenticatedOrReadOnly , потому что пользователь должен аутентифицироваться, чтобы создать пост, а вот просматривать список может любой пользователь.


Для PostDetails нужны оба разрешения, поскольку обновлять или удалять пост должен только залогиненный пользователь, а также его владелец. Для получения поста прав не нужно. Вернитесь на http://127.0.0.1:8000/posts. Зайдите в учетную запись admin и другие, чтобы проверить, какие действия доступны аутентифицированным и анонимным пользователям.


Будучи разлогиненным, вы не должны иметь возможность создавать, удалять или обновлять посты. При аутентификации вы не должны иметь право удалять или редактировать чужие посты.


Django REST framework Log Out


Создание API для Comments


Теперь у вас есть базовый API для постов. Можно добавить в систему комментарии.


Комментарий — это текст, который пользователь добавляет в ответ на пост другого пользователя. К одному можно оставить несколько комментариев, а у поста может быть несколько комментариев от разных пользователей. Это значит, что нужно настроить две пары отношений многие-к-одному: между комментариями и пользователями, а также между комментариями и постами.


Модель Comment


Сначала создайте модель в blog/api/models.py:





Похожие публикации:
    

  1. Как написать игру на java
    2. 

  2. Как написать скрипт для windows
    3. 

  3. Как настроить камеру на самсунг а 32
    4. 

  4. Как сделать обратные кавычки js
    5.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *