Django – #26 – REST API cz. 2 – ListAPIView

Posted on Author Dominik Bednarski 0

Wprowadzenie.

Po pierwszym wpisie, który przygotował grunt pod naszą aplikacją typu REST, przedstawiam krok po kroku jak uruchomić pierwszą aplikację REST API. W tym wpisie pokażę co zrobić, aby nasz serwer wysyłał dane znajdujące się w bazie danych, jeżeli dostanie zapytanie get.

  1. Django REST API cz. 1– Tworzenie nowego projektu 
  2. Django REST API cz. 2 – ListAPIView 
  3. Django REST API cz. 3 – Wbudowana strona logowania
  4. Django REST API cz. 4 – Widoki generyczne
  5. Django REST API cz. 5 – ListCreateAPIView i konfiguracja dostępu 
  6. Django REST API cz. 6 – Uszczegóławianie odpowiedzi
  7. Django REST API cz. 7 – Określenie z góry wartości danych
  8. Django REST API cz. 8 – RetrieveDestroyAPIView
  9. Django REST API cz. 9 – RetrieveUpdateAPIView
  10. Django REST API cz. 10 – Nadpisywanie zachowań metod przed/po operacji zapisu/usuwania
  11. Django REST API cz. 11 – Rejestracja nowego użytkownika poprzez API  
  12. Django REST API cz. 12 – Uwierzytelnianie przy pomocy Tokena 
  13. Django REST API cz. 13 – Generowanie tokena dla istniejących użytkowników

Zakres artykułu.

  • Listowanie danych – ListAPIView

Listowanie danych - ListAPIView

W pierwszym kroku do naszego projektu w pliku settings.py dodajemy do listy zainstalowanych aplikacji framework REST.

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

Następnie w pliku models.py tworzymy modele Author, Book oraz Borrow, w celu utworzenia prostej struktury biznesowej aplikacji. 

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

# Create your models here.

class Author(models.Model):
    first_name = models.CharField(max_length=64)
    last_name = models.CharField(max_length=64)

    def __str__(self):
        return self.first_name + ' ' + self.last_name

class Book(models.Model):
    title = models.CharField(max_length=128)
    author_id = models.ForeignKey(Author, on_delete=models.CASCADE)

    def __str__(self):
        return self.title

class Borrow(models.Model):
    user_id = models.ForeignKey(User, on_delete=models.CASCADE)
    book_id = models.ForeignKey(Book, on_delete=models.CASCADE)
    borrow_date = models.DateTimeField(auto_now_add=True)
    return_date = models.DateTimeField(blank=True, null=True)

    def __str__(self):
        return self.user_id.first_name + ' ' + self.user_id.last_name + ' - ' + self.borrow_date.strftime("%Y-%m-%d %H:%M:%S")

W następnym kroku rejestrujemy nasze modele, tak aby był widoczne w panelu administratora. W tym celu w pliku admin.py znajdującego się w folderze naszej aplikacji importujemy nasze modele a następnie, wywołujemy metodę register().

from django.contrib import admin
from .models import Author, Book, Borrow

# Register your models here.

admin.site.register(Author)
admin.site.register(Book)
admin.site.register(Borrow)

Na tym etapie z migrujmy utworzone modele bazy danych i uruchommy serwer w celu przeprowadzenia testów.

$ source myvenv/bin/activate
$ python manage.py makemigrations
$ python manage.py migrate
$ python manage.py runserver

Teraz z panelu administratora do tabel Users, Authors, Books oraz Borrows wprowadźmy jakieś dane. W moim przypadku dane do testowania wyglądają następująco.

Tabela Users

Tabela Authors

Tabela Books

Tabela Borrows

Mając dane do testowania, możemy przejść do kolejnego kroku, czyli należy zastosować tak zwany serializer. Jak możmy przeczytać na oficjalnej stronie serializery pozwalają na konwersję złożonych danych, takich jak zbiory zapytań i instancje modeli, do natywnych typów danych Pythona, które mogą być następnie przekształcone do formatu JSON, XML lub też innego typu. Serializery zapewniają również deserializację, pozwalając na konwersję sparsowanych danych z powrotem do złożonych typów, po uprzednim sprawdzeniu poprawności przychodzących danych.

W katalogu naszej aplikacji tworzymy nowy plik o nazwie serializers.py, a następnie tworzymy serializery dla modeli.

from rest_framework import serializers
from .models import Author, Book, Borrow

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'first_name', 'last_name']

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author_id']

class BorrowSerializer(serializers.ModelSerializer):
    class Meta:
        model = Borrow
        fields = ['id', 'user_id', 'book_id', 'borrow_date', 'return_date']

W kolejnym kroku w pliku views.py stwórzmy widoki, dzięki którym będziemy w stanie wylistować dane o autorach, książkach i wypożyczeniach. Żaby ułatwić sobie pracę skorzystamy z klasy generycznej ListAPIView. Klasa ta wykorzystywana jest tylko do odczytu kolekcji instancji modelu i obsługuje tylko metodę get. 

from django.shortcuts import render
from rest_framework import generics
from .models import Author, Book, Borrow
from .serializers import AuthorSerializer, BookSerializer, BorrowSerializer

# Create your views here.
class AuthorList(generics.ListAPIView):
    queryset = Author.objects.all()
    serializer_class = AuthorSerializer

class BookList(generics.ListAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

class BorrowList(generics.ListAPIView):
    queryset = Borrow.objects.all()
    serializer_class = BorrowSerializer

Jak już mamy gotowe widoki to następnie należy utworzyć ścieżki url dla tych widoków.

from django.contrib import admin
from django.urls import path
from restapiapp import views

urlpatterns = [
    path('admin/', admin.site.urls),

    # API
    path('api/authors', views.AuthorList.as_view()),
    path('api/books', views.BookList.as_view()),
    path('api/borrows', views.BorrowList.as_view()),
]

Na koniec możemy przetestować nasze API poprzez wpisanie w przeglądarkę następujących adresów:

  • http://127.0.0.1:8000/api/authors
  • http://127.0.0.1:8000/api/books
  • http://127.0.0.1:8000/api/borrows

Inną możliwością testowania jest skorzystanie z konsoli i polecenia curl (jeżeli mamy je zainstalowane). W tym celu w konsoli należy wpisać następujące polecenia:

$ curl http://127.0.0.1:8000/api/authors
$ curl http://127.0.0.1:8000/api/books
$ curl http://127.0.0.1:8000/api/borrows

W ten oto sposób stworzyliśmy swoje pierwsze REST API, które na chwilę obecną pozwala jedynie pobrać dane z serwera i je wylistować. 

  1. Django REST API cz. 1– Tworzenie nowego projektu 
  2. Django REST API cz. 2 – ListAPIView 
  3. Django REST API cz. 3 – Wbudowana strona logowania
  4. Django REST API cz. 4 – Widoki generyczne
  5. Django REST API cz. 5 – ListCreateAPIView i konfiguracja dostępu 
  6. Django REST API cz. 6 – Uszczegóławianie odpowiedzi
  7. Django REST API cz. 7 – Określenie z góry wartości danych
  8. Django REST API cz. 8 – RetrieveDestroyAPIView
  9. Django REST API cz. 9 – RetrieveUpdateAPIView
  10. Django REST API cz. 10 – Nadpisywanie zachowań metod przed/po operacji zapisu/usuwania
  11. Django REST API cz. 11 – Rejestracja nowego użytkownika poprzez API  
  12. Django REST API cz. 12 – Uwierzytelnianie przy pomocy Tokena 
  13. Django REST API cz. 13 – Generowanie tokena dla istniejących użytkowników

Autor artykułu
Dominik Bednarski

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany.