RESTful API dengan Django dan REST Framework

Sebelumnya kita sudah berhasil membuat Django project dan app. Anda juga sudah berhasil menjalankan proyek Django. Seperti yang Anda ketahui, RESTful API adalah API yang menerapkan arsitektur REST. Arsitektur REST memiliki client dan server. Client akan mengirimkan HTTP request ke server. Server akan menerimanya dan memprosesnya. Kemudian, server akan mengirimkan HTTP response ke client. Lalu, bagaimana proses ini terjadi? Sebelum itu, kita bahas terlebih dahulu pengertiannya.

Django

Django adalah kerangka web Python yang dapat mendukung pengembangan yang cepat dan desain kode yang bersih. Django menangani sebagian besar hal-hal yang sering dilakukan dalam pengembangan web sehingga developer bisa fokus menulis logika bisnis. Django dapat digunakan secara gratis dan open source. Django memiliki perhatian yang serius terhadap keamanan yang dapat membantu pengembang menghindari kesalahan dalam keamanan.

Jangan khawatir ketika ingin menggunakan Django di level produksi karena Django sangat stabil dan telah digunakan oleh perusahaan, seperti Disqus, Instagram, Pinterest, dan Mozilla bertahun-tahun. Django didukung oleh yayasan independen yang bernama Django Software Foundation. Selain itu, Django juga disebut sebagai web framework “battery-included” karena ia menyediakan banyak fitur esensial yang sudah tersedia secara default, seperti autentikasi, keamanan, sistem admin, routing, ORM (Object Relational Mapping), bahkan panel web admin yang ditampilkan otomatis dari ORM.

Kerangka Kerja REST

Django REST Framework (DRF) adalah toolkit untuk membangun RESTful API. REST Framework berjalan di atas Django sebagai Django app. Setelah memasang REST Framework, Anda wajib untuk mendaftarkannya pada INSTALLED_APPS. Sesuai dengan definisinya, toolkit, REST Framework memiliki banyak utilitas yang dapat membantu developer dalam membangun RESTful API yang andal dengan cepat.

Django sebenarnya dikhususkan untuk aplikasi web yang memiliki tampilan halaman HTML (full-stack), sedangkan REST Framework dikhususkan untuk RESTful API. REST Framework menawarkan fitur yang membantu dalam mengembangkan RESTful API seperti serialization dan viewset (yang menggabungkan aksi seperti CRUD di dalam satu class).

Lalu, apa saja alasan yang membuat pengembang memilih menggunakan REST Framework? Berikut beberapa insentif.

Komunitas dan Pengguna Yang Besar

REST Framework memiliki komunitas yang besar, Anda dapat menyimak diskusi dan bertanya di forum yang ada di Google Groups . Selain itu, REST Framework digunakan dan dipercaya oleh perusahaan internasional seperti Mozilla, Red Hat, dan Heroku.

API yang dapat dijelajahi

REST Framework mendukung dokumentasi API yang ramah untuk dibaca oleh manusia untuk semua sumber daya. Browsable API memudahkan kita untuk mencoba API seperti mengirimkan data dan menampilkan data melalui tampilan HTML yang dibuat secara otomatis oleh REST Framework.

Sesuai dengan namanya, Browsable API , Anda dapat berselancar untuk melihat dan mencoba API. Pada contoh di atas, Anda dengan mudah mencoba melakukan permintaan HTTP dengan mengklik GET. Selain itu, Anda juga dapat melihat responnya dengan mudah.

Serialisasi

Serializers adalah alat yang dapat mengubah data dari struktur data yang kompleks seperti model menjadi tipe data asli yang ada di Python sehingga memudahkan untuk mengubahnya menjadi format yang diinginkan seperti JSON atau XML. Selain itu, serializer juga mempunyai fitur deserialisasi. Deserialisasi digunakan untuk mengubah data dari tipe data asli Python menjadi struktur data yang kompleks.

Di kelas ini, kita akan menggunakan REST Framework versi 3.15. Django dan REST Framework memiliki perbedaan dalam menangani RESTful API . Penasaran dengan perbedaannya? Jika iya, ayo kita mulai!

Permintaan HTTP

Yang pertama, kita akan melihat cara Django untuk menangani permintaan HTTP. Untuk membuat RESTful API yang dapat menerima permintaan HTTP, Django memanfaatkan tampilan. View function (disingkat view) adalah fungsi Python yang dapat menerima permintaan dan mengembalikan respons. Respon dari view bisa dalam bentuk HTML, XML, redirect dan lain-lain.

View akan dituliskan di dalam Django app.

Misalnya, membuat RESTful API untuk menyimpan daftar film. Pertama, menuliskan view yang akan menerima permintaan HTTP dalam berkas views.py.

from django.http import HttpResponse 
from  django.views.decorators.csrf import csrf_exempt  
from django.http import HttpResponse 
from django.views.decorators.csrf import csrf_exempt
 
@csrf_exempt
film definisi ( permintaan ):
    jika metode permintaan == ' GET' : 
        respon = "Agak Laen, Warkop DKI Reborn Part 1, Pengabdi Setan 2, Dilan, Sewu Dino" 
        kembalikan HttpResponse ( respons ) 
    elif request.method == ' POST ' : 
        respon = "Data film berhasil ditambahkan." 
        kembalikan HttpResponse ( respons ) 
    # kalau tidak
    respon = f "Halaman tidak dapat diakses menggunakan {request.method} request"
    kembalikan HttpResponse ( respons )

Pada contoh di atas, tampilan akan menerima permintaan HTTP dengan kata kerja/metode HTTP GET dan POST. View akan memeriksa HTTP verbs/method yang dikirimkan, jika HTTP verbs/method-nya adalah GET, blok kode di dalam if akan dijalankan. Jika tidak, blok kode elif akan dijalankan. Response dari view tersebut berbentuk HTML yang berasal dari HttpResponse.

Setelah memasukkan view, tambahkan file baru bernama urls.py dan tuliskan URL baru di dalam file tersebut.

dari django.urls impor path
 
dari . impor  tampilan  
 
urlpatterns = [ 
    jalur ( "film" , tampilan . film ),
]

Tidak cukup jika hanya menambahkan URL di urls.py milik Django app, URL tersebut perlu untuk didaftarkan di dalam proyek Django. Caranya adalah menuliskan kode seperti berikut di urls.py milik Django project.

dari django.contrib impor admin
from django.urls import path , include
impor debug_toolbar
 
urlpatterns = [ 
    jalur ( '' , sertakan ( 'first_app.urls' )),
    jalur ( 'admin/' , admin . situs . url ),
]

Teknik yang kita lakukan itu adalah routing. Routing adalah cara merutekan URL ke fungsi tampilan. Ketika pengguna mengetikkan sebuah alamat URL, URL tersebut akan diteruskan ke urls.py. Kemudian di urls.py akan dicocokkan URL yang terdaftar dengan yang dipanggil.

Jika URL ditemukan, fungsi tampilan akan dipanggil. Jika tidak, kita harus menanganinya, di Django harus ditangani secara manual, sedangkan di Django REST framework akan ditangani secara otomatis.

Kemudian, ketika HTTP request dijalankan menggunakan CURL , akan tampak hasil seperti berikut.

Selain itu, jika mengirimkan HTTP request POST, akan memberikan hasil seperti gambar di bawah ini.

Contoh di atas masih merupakan permintaan HTTP sederhana. Bagaimana jika ingin menambahkan data dengan metode POST? Tentunya klien akan mengirimkan data melalui permintaan HTTP. Untuk melakukan itu, klien akan mengirimkannya melalui badan permintaan. Yuk, kita simak cara Django menangani request body pada materi selanjutnya!

Masih sama seperti Django, REST Framework menggunakan view untuk menerima permintaan dan mengembalikan respons. Selain itu, untuk mendaftarkan URL juga masih sama, kita perlu menuliskannya di Django app dan Django project. Perbedaan yang terlihat dari Django dengan REST Framework adalah pada bagian view.

from rest_framework.decorators import api_view
from  rest_framework.response import Response  
 
@api_view ()
 film definisi ( permintaan ):
    jika metode  permintaan == ' GET' : 
        respon = '{ "film": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }' 
        kembalikan Respons ( respons )

Pada contoh di atas, kami menggunakan dekorator @api_view yang dimiliki oleh REST Framework. @api_view akan mengambil permintaan HTTP dan mengembalikan respons. Secara default, metode HTTP yang diizinkan hanyalah GET. Untuk menangani metode lainnya, Anda harus menuliskannya secara spesifik di dalam @api_view() seperti berikut.

@api_view ([ 'GET' , 'POST' ]) 
 film definisi ( permintaan ):
    jika metode  permintaan == ' GET' : 
        respon = '{ "film": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }' 
        kembalikan Respons ( respons ) 
    elif  request.method == ' POST ' : 
        respon = '{ "message": "Data film berhasil ditambahkan." }' 
        kembalikan Respons ( respons )

Selain itu, kita tidak lagi menggunakan HttpResponse yang akan mengembalikan respon dalam bentuk teks karena REST Framework akan menggunakan objek Response yang menghasilkan respon dalam format JSON. Terlihat terlihat perbedaan antara Django dengan REST Framework.

Ketika dijalankan, hasilnya akan tampak seperti berikut.

Keunggulan lainnya adalah ketika mengakses http://127.0.0.1:8000/movies di browser, secara otomatis akan tersedia browsable API seperti berikut.

Anda dapat membuat permintaan HTTP dengan sangat mudah menggunakan formulir web. Menarik bukan? Yuk, kita lanjutkan ke cara REST Framework menangani request body.

Isi Permintaan

Request body adalah data yang dikirimkan client ke server atau API. Data yang dikirimkan dalam format teks, JSON, berkas gambar, atau format lainnya. Data tersebut nantinya digunakan oleh server untuk diproses dengan database atau disimpan dalam bentuk objek utuh. Untuk menggunakan data tersebut, server atau web service harus dapat menerima data. Agar bisa menerima data, web service biasanya menggunakan request body. Request body secara umum digunakan untuk HTTP methods selain GET, seperti POST, PUT, dan DELETE.

Django juga mendukung untuk memproses isi permintaan. Misalnya, ketika ingin menambahkan data movie. Django harus dapat menerima data yang dikirimkan (badan permintaan). Berikut cara Django menerima badan permintaan.

film definisi ( permintaan ):
    jika request.method == ' GET ' : 
        respon = "Agak Laen, Warkop DKI Reborn Part 1, Pengabdi Setan 2, Dilan, Sewu Dino" 
        kembalikan HttpResponse ( respon )
    jika request.method == ' POST ' : 
        isi = isi permintaan
        respon = f "Data film {body} berhasil ditambahkan."
        kembalikan HttpResponse ( respon )
    
    # Mengembalikan respons jika metode HTTP tidak didukung
    respon = f "Halaman tidak dapat diakses menggunakan {request.method} request"
    kembalikan HttpResponse ( respon )

Pada contoh di atas, lihat menerima request body melalui class HttpRequest dan atributnya yang bernama body dan menyimpannya dalam variabel body. body digunakan untuk menerima data mentah ( raw ) dalam bentuk string byte , jadi, kita perlu mengubahnya menjadi string yang dapat dibaca manusia. body biasanya digunakan untuk data yang bukan dari form HTML, seperti data gambar, XML, dan JSON.

Jika mengirimkan HTTP request POST, hasilnya akan tampak seperti berikut.

Pada contoh di atas, kami mengirimkan permintaan HTTP dengan metode POST dengan parameter -d (--data) dan -h (--header). Parameter -d digunakan untuk mengirimkan data, sedangkan -h digunakan untuk menambahkan header ke HTTP. Selain itu, data yang dikirimkan adalah film dengan nama Habibie & Ainun.

Protokol HTTP mentah mengirimkan badan permintaan sebagai string byte. Kenapa ada awalan b pada respon di atas? Karena Python menandai string byte dengan awalan b (Anda dapat melihatnya pada gambar di atas).

Untuk mengubahnya menjadi string, Anda dapat melakukannya seperti berikut.

@csrf_exempt
film definisi ( permintaan ):
    jika request.method == ' GET ' : 
        respon = "Agak Laen, Warkop DKI Reborn Part 1, Pengabdi Setan 2, Dilan, Sewu Dino" 
        kembalikan HttpResponse ( respon )
    jika request.method == ' POST ' : 
        isi = isi permintaan
        data_decode = body.decode ( ' UTF -8' )
        respon = f "Data film {data_decode} berhasil ditambahkan."
        kembalikan HttpResponse ( respon )
    # Mengembalikan respons jika metode HTTP tidak didukung
    respon = f "Halaman tidak dapat diakses menggunakan {request.method} request"
    kembalikan HttpResponse ( respon )

UTF-8 adalah pengkodean karakter standar untuk komunikasi elektronik. Jika ingin mengetahui pengkodean yang digunakan pada permintaan HTTP, Anda dapat menggunakan HttpRequest.encoding .
Baris kode berikut: data_decode = body.decode('UTF-8') berfungsi untuk mengubah byte string menjadi string. Jika dijalankan kembali, hasilnya akan berubah seperti berikut.

Huruf b yang tadinya ada, sekarang sudah hilang. Artinya, kita sudah berhasil mengubah byte string menjadi string.

request.body cocok digunakan untuk menerima data yang dikirim dalam format selain form HTML. Jika Anda ingin menerima data yang dikirimkan melalui form HTML, gunakan atribut POST milik HttpRequest , yaitu request.POST.

nama = request.POST.get ( " nama " )
respon = f "Data film {name} berhasil ditambahkan."

Data yang ada di request.POST memiliki bentuk seperti kamus sehingga untuk memprosesnya pun kita memperlakukannya seperti kamus , yaitu dengan get untuk mendapatkan data dari key -nya. Pada contoh di atas, key yang dikirim di form HTML adalah name.

Oke, sekarang kita sudah bisa menerima data dari request body. Namun, bagaimana jika web service atau server ingin mengetahui header dari suatu permintaan HTTP yang dilakukan klien? Anda masih ingat kan, bahwa HTTP request memiliki header?

REST Framework menangani badan permintaan menggunakan request.data. request.data akan mengembalikan data yang sudah di-parse sehingga data tersebut bisa langsung digunakan tanpa harus mengonversinya. request.data mendukung metode HTTP selain POST seperti PATCH dan PUT. Berikut contoh kodenya.

@api_view ([ 'GET' , 'POST' ]) 
 film definisi ( permintaan ):
    jika metode  permintaan == ' GET' : 
        respon = '{ "film": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }' 
        kembalikan Respons ( respons ) 
    elif  request.method == ' POST ' : 
        isi = permintaan.data
        respons = { 
            "message" : "Data film berhasil ditambahkan." , 
            "data" : isi
        }
        kembalikan Respons ( respons )

Ketika menggunakan request.data, data yang dikirimkan harus bertipe JSON. Oleh karena itu, ketika mengirimkannya Anda harus menambahkan Content-Type saat melakukan permintaan HTTP seperti berikut.

Berbeda dengan Django, data yang diperoleh dari request body oleh REST Framework bukanlah string byte melainkan kamus. REST Framework secara otomatis mengubah (parsing) data menjadi dictionary agar mudah untuk dimanipulasi. Keren, kan?

Setelah berhasil membaca request body dengan REST Framework, selanjutnya kita akan melihat cara REST Framework membaca header dari sebuah request.

Header Permintaan

Request header dapat berisi data yang penting tentang klien yang mengirimkan permintaan HTTP. Untuk mendapatkan HTTP Header, Django dapat membaca melalui class HttpRequest dan atribut headers . Di dalam header, terdapat informasi seperti content-type , content-length , user-agent dan sebagainya. Oh iya, request header dapat dilakukan pada semua HTTP verbs/method (GET, POST, PUT, DELETE).

Misalnya, ketika ingin mendapatkan header content-type dari sebuah permintaan HTTP. Di Django, dapat dilakukan seperti berikut.

@csrf_exempt
 film definisi ( permintaan ):
    jika metode  permintaan == ' GET' : 
        respon = "Agak Laen, Warkop DKI Reborn Part 1, Pengabdi Setan 2, Dilan, Sewu Dino" 
        kembalikan HttpResponse ( respons ) 
    elif  request.method == ' POST ' : 
        isi = permintaan.isi
        data_decode = body.decode ( ' UTF -8' )
        respon =  f "Data film {data_decode} berhasil ditambahkan."
        kembalikan HttpResponse ( respons ) 
    elif  request.method == ' PUT ' : 
        content_type = request.headers [ 'content- type ' ]
        kembalikan HttpResponse ( tipe_konten ) 
    
    # Mengembalikan respons jika metode HTTP tidak didukung
    respon =  f "Halaman tidak dapat diakses menggunakan {request.method} request"
    kembalikan HttpResponse ( respons )

Satu blok elif baru ditambahkan, yang menerima permintaan HTTP dengan metode PUT. Di dalam blok elif tersebut, kita menggunakan atribut headers untuk mendapatkan nilai content-type.

Jika mengirimkan HTTP PUT request ke URL http://127.0.0.1:8000/movies , hasilnya akan seperti berikut.

Anda dapat melihat content-type dari HTTP request pada contoh di atas adalah text/plain. Oke, saat ini, kita sudah bisa membaca header dari sebuah permintaan HTTP. Muncul tantangan berikutnya, bagaimana cara membaca URL yang dinamis seperti https://www.dicoding.com/academies/261 ? Untuk membaca URL yang dinamis, kita akan menggunakan teknik parameter jalur.

REST Framework menggunakan kelas HttpRequest milik Django. Oleh karena itu, semua atribut dan method standar yang ada di class tersebut dapat digunakan.

Misalnya, ketika ingin mendapatkan content-type dari sebuah permintaan HTTP. Di REST Framework caranya sama seperti di Django. Berikut contoh implementasinya.

@api_view ([ 'GET' , 'POST' , 'PUT' ])  
 film definisi ( permintaan ):
    jika metode  permintaan == ' GET' : 
        respon = '{ "film": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }' 
        kembalikan Respons ( respons ) 
    elif  request.method == ' POST ' : 
        isi = permintaan.data
        respons = { 
            "message" : "Data film berhasil ditambahkan." , 
            "data" : isi
        }
        kembalikan Respons ( respons ) 
    elif  request.method == ' PUT ' : 
        content_type = request.headers [ 'content- type ' ]
        kembalikan Respons ( tipe_konten )

Jika dijalankan, hasilnya akan seperti berikut.

Kerja bagus !
Saat ini kita sudah tahu cara membaca header dari sebuah permintaan. Selanjutnya, kita akan melihat cara REST Framework untuk menangani URL dinamis dengan parameter path.

Parameter Jalur

Path adalah alamat yang digunakan client untuk melakukan permintaan HTTP ke server. Path dibuat dengan bahasa yang mudah dipahami oleh klien. Selain itu, path dapat menggambarkan sumber daya atau layanan apa yang ingin diminta oleh klien ke server.

Misalnya, ketika mengakses kelas Dicoding, https://www.dicoding.com/academies/261, kita dengan mudah mengetahui bahwa client ingin meminta resources bernama academies, dengan ID 261 ke server Dicoding. Teknik yang digunakan oleh Dicoding tersebut adalah teknik path parameter.

Django juga dapat mengimplementasikan parameter Path. Misalnya, ketika ingin mengakses film dengan id tertentu, hal pertama yang dilakukan adalah menambahkan URL baru di aplikasi Django.

dari django.urls impor path
 
dari . impor  tampilan  
 
urlpatterns = [ 
    jalur ( "film" , tampilan . film ),
    jalur ( "film/<int:id>" , tampilan . detail_film ),
]

Ada yang berbeda di URL yang baru, yaitu adanya penambahan id setelah /movies. id tersebut bertipe data integer. Karena sebelumnya kita sudah menambahkan URL aplikasi Django di proyek Django, kini tidak perlu menambahkannya lagi.

Kemudian, di dalam view tambahkan view function baru.

@csrf_exempt
def movies(request):
    if request.method == 'GET':
        response = "Agak Laen, Warkop DKI Reborn Part 1, Pengabdi Setan 2, Dilan, Sewu Dino"
        return HttpResponse(response)
    elif request.method == 'POST':
        body = request.body
        data_decode = body.decode('UTF-8')
        response = f"Data movie {data_decode} berhasil ditambahkan."
        return HttpResponse(response)
    elif request.method == 'PUT':
        content_type = request.headers['content-type']
        return HttpResponse(content_type)
    
    # Mengembalikan respon jika metode HTTP tidak didukung
    response = f"Halaman tidak dapat diakses menggunakan {request.method} request"
    return HttpResponse(response)
 
// Function baru
def detail_movie(request, id):
    response = f"Menampilkan detail movie dengan id {id}
    return  HttpResponse(response)

Untuk mendapatkan path dari HTTP request, kita cukup menambahkan parameter baru di view function. Pada contoh di atas, parameternya adalah id.

Ketika diuji, misalnya, ingin mendapatkan movie dengan id 1, akan tampak hasilnya seperti gambar di bawah ini.

Oke, satu teknik baru telah kita pelajari. Namun, path parameter saja tidaklah cukup. Client mungkin ingin melakukan HTTP request yang lebih beragam. Misalnya, client ingin mencari data dengan kata kunci tertentu. Bagaimana caranya? Caranya dengan menggunakan query parameter. Yuk, kita berkenalan dengannya di materi setelah ini.

REST Framework

Sama halnya dengan request header, penanganan path parameter di REST Framework serupa dengan Django. Untuk menangani path parameter, kita perlu menambahkan URL di urls.py dalam Django app.

dari django.urls impor jalur
dari . impor tampilan
urlpatterns = [
    jalur("film", tampilan.film),
    jalur("film/<int:id>", tampilan_detail_film),
]

Kemudian, tambahkan view baru.

@api_view()
def detail_movie(request, id):
    respon = f"Menampilkan detail film dengan id {id}"
    kembalikan Respons(respons)

Hal yang berbeda di sini adalah adanya decorator @api_view dan responnya yang menggunakan Response. Ketika dijalankan, hasilnya akan tampak seperti berikut.

Nice! URL dinamis pun kita sudah bisa menanganinya dengan REST Framework. Selanjutnya, kita akan telusuri cara REST Framework untuk menangani query parameter.

Query Parameter

Query parameter adalah teknik yang umum digunakan untuk mencari atau memfilter data. Query parameter ditulis di akhir alamat URL dan dipisahkan oleh tanda tanya (?). Query parameter memiliki format key=value. Selain itu, query parameter ini bersifat opsional. Jadi, ketika nilainya kosong, aplikasi tidak boleh mengalami error.

Contoh, ketika ingin mencari akun youtube Dicoding, URL-nya akan tampak seperti https://www.youtube.com/results?search_query=dicoding, key-nya adalah search_query dan value-nya adalah dicoding.

Bagaimana cara mendapatkan nilai query parameter di Django? Untuk mendapatkannya, kode berikut perlu ditambahkan di dalam function movies views.py.

pencarian = permintaan.GET.get('pencarian')
jika pencarian:
    respon = f"Mencari film menggunakan parameter query dengan kata kunci: {search}"
    kembalikan HttpResponse(respons)

Sehingga kode lengkap function movies sebagai berikut.

@csrf_exempt
def movies(request):
    jika request.method == 'GET':
        pencarian = permintaan.GET.get('pencarian')
        jika pencarian:
            # Respon untuk pencarian film
            respon = f"Mencari film menggunakan parameter query dengan kata kunci: {search}"
            kembalikan HttpResponse(respons)
        
        # Respon default untuk daftar film
        respon = "Agak Laen, Warkop DKI Reborn Part 1, Pengabdi Setan 2, Dilan, Sewu Dino"
        kembalikan HttpResponse(respons)
    jika request.method == 'POST':
        isi = isi permintaan
        data_decode = body.decode('UTF-8')
        respon = f"Data film {data_decode} berhasil ditambahkan."
        kembalikan HttpResponse(respons)
    jika metode permintaan == 'PUT':
        tipe_konten = permintaan.header['tipe_konten']
        kembalikan HttpResponse(content_type)
    # Mengembalikan respons jika metode HTTP tidak didukung
    respon = f"Halaman tidak dapat diakses menggunakan {request.method} request"
    kembalikan HttpResponse(respons)

Ingat, query parameter memiliki key. Oleh karena itu, pada contoh di atas, kita memanggil key-nya yaitu “search” untuk mendapatkan value-nya. Jika query parameter kosong, blok kode yang ada di dalam if tidak akan dieksekusi.

Misalnya, Anda ingin mencari movie yang berjudul “Agak Laen”. Untuk mengujinya, buatlah HTTP request dengan query parameter berikut.

curl -X GET http://127.0.0.1:8000/movies\?search\=Agak+Laen -i

Tanda backslash (\) digunakan untuk escape karakter tanda tanya (?). Kenapa perlu di-escape? Karena karakter tanda tanya perlu untuk diperlakukan khusus dibandingkan dengan karakter lain. Karena di dalam URL tidak boleh ada spasi, kita menambahkan tanda tambah (+) untuk menggantikan spasi.

Hasilnya akan tampak seperti berikut.

Jika query parameter-nya bernilai kosong, aplikasi akan tetap berjalan seperti sedia kala dan hasilnya akan tampak seperti berikut.

Karena query parameter bernilai kosong, blok if search tidak akan dijalankan.

Saat ini, kita telah berhasil menangani HTTP request seperti request body, path parameter dan query parameter. Selain itu, Anda juga telah melihat response yang diberikan oleh masing-masing teknik tersebut.

Namun, kita belum mendalami response yang diberikan oleh HTTP request. Mungkin sebagian dari Anda bertanya-tanya tentang maksud dari response tersebut, atau Anda mungkin bertanya bagaimana untuk mengubah response tersebut. Untuk menjawab pertanyaan tersebut, mari kita bahas terkait response.

Di REST Framework, untuk mendapatkan query parameter tidak menggunakan request.GET, melainkan menggunakan request.query_params. Meskipun fungsi dari request.query_params dan request.GET terlihat sama, mereka sebenarnya memiliki perbedaan. Apa perbedaanya? Perbedaannya adalah query_params lebih jelas dan mudah dibaca.

Berikut contoh implementasinya.

@api_view(['GET', 'POST', 'PUT'])
def movies(request):
    jika request.method == 'GET':
        pencarian = permintaan_parameter_kueri dapatkan("pencarian")
        jika pencarian:
            # Respon untuk pencarian film
            respon = f"Mencari film menggunakan parameter query dengan kata kunci: {search}"
            kembalikan Respons(respons)
        # Respon default untuk daftar film
        respon = '{ "film": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }'
        kembalikan Respons(respons)
    jika request.method == 'POST':
        isi = data permintaan
        respons = {
            "message": "Data movie berhasil ditambahkan.",
            "data": body
        }
        return Response(response)
    elif request.method == 'PUT':
        content_type = request.headers['content-type']
        return Response(content_type)

Untuk mengambil nilai dari query params, dilakukan dengan cara menuliskan key di dalam request.query_params.get. query_params dapat digunakan juga untuk HTTP method/verbs selain GET.

Misalnya, ingin mencari movie yang berjudul “Dilan”. Ketika dijalankan dengan cURL, hasilnya seperti berikut.

Berhasil!
Saat ini, Anda sudah tahu cara menangani query parameter. Selanjutnya, yuk kita lihat bagaimana REST Framework menangani response body!

Response Body

Masih ingatkah Anda bahwa di dalam HTTP response terkandung beberapa informasi seperti Status line, Header, dan Body? Jika tidak, mari kita bahas kembali.

HTTP response yang diberikan oleh server mengandung beberapa informasi seperti berikut.

Status line: berisikan HTTP versi yang digunakan; status code, reason phrase atau status text yang merupakan pesan berdasarkan status code dalam bentuk teks.
Header: mengandung informasi yang dilampirkan terkait response seperti format dokumen.
Body (opsional, namun biasanya selalu dilampirkan): memuat data yang dikirimkan oleh server dalam bentuk HTML, JSON, gambar, dan sebagainya.

Nah, di contoh sebelumnya, Anda sudah melihat ketiga informasi yang ada di HTTP response seperti berikut.

Pada contoh di atas, terdapat status line (HTTP/1.1, 200 dan OK), Header (Content-type) dan Body (“Ini adalah response GET request.”). Apakah informasi yang ada di HTTP response dapat diubah? Iya, informasi yang ada di HTTP response dapat diubah.

Misalnya, ingin mengembalikan response berupa byte string. Di Django, untuk menerapkan hal itu dilakukan dengan cara seperti berikut.

@csrf_exempt
def movies(request):
    if request.method == 'GET':
        search = request.GET.get('search')
        if search:
            # Respon untuk pencarian film
            response = f"Mencari movies menggunakan query parameter dengan kata kunci: {search}"
            return HttpResponse(response)
 
        # Respon default untuk daftar film
        response = b"Agak Laen, Warkop DKI Reborn Part 1, Pengabdi Setan 2, Dilan, Sewu Dino"
        return HttpResponse(response)
    elif request.method == 'POST':
        body = request.body
        data_decode = body.decode('UTF-8')
        response = f"Data movie {data_decode} berhasil ditambahkan."
        return HttpResponse(response)
    elif request.method == 'PUT':
        content_type = request.headers['content-type']
        return HttpResponse(content_type)
 
    # Mengembalikan respon jika metode HTTP tidak didukung
    response = f"Halaman tidak dapat diakses menggunakan {request.method} request"

Untuk mengubah response body menjadi byte string, Python secara sintaksis menggunakan awalan huruf b sebelum string, jika tipe data yang diinginkan adalah byte string. Contohnya dapat dilihat pada kode di atas, di variabel response yang berada di luar blok if search.

Byte string digunakan untuk memproses berkas gambar atau XML. Pada contoh di atas, byte string yang dikembalikan bukanlah berkas gambar atau XML. Oleh karena itu, jika dijalankan hasilnya akan tampak sama seperti sebelumnya.

Jika Anda kurang yakin bahwa response yang dihasilkan adalah byte string, print tipe datanya di Terminal PyCharm.

response = b"Agak Laen, Warkop DKI Reborn Part 1, Pengabdi Setan 2, Dilan, Sewu Dino"
print(type(response))

Hasilnya berikut ini.

Untuk saat ini, kita sudah bisa mengubah response yang berupa string menjadi byte string. Memang secara hasil akan terlihat sama tetapi dibalik layar sebenarnya kedua hal itu berbeda.

Mengubah response body saja tidaklah cukup, di suatu kasus, kita butuh untuk mengubah response header dari sebuah HTTP request.

Seperti yang Anda ketahui, ketika menggunakan objek Response di REST Framework, data yang dikembalikan akan berbentuk JSON. Lalu, bagaimana jika kita mempunyai kasus yang mengharuskan untuk mengembalikan data dalam bentuk selain JSON? Untuk melakukannya, kita dapat menulis kode seperti berikut.

@api_view(['GET', 'POST', 'PUT'])
def movies(request):
    if request.method == 'GET':
        search = request.query_params.get("search")
        if search:
            # Respon untuk pencarian film
            response = f"Mencari movies menggunakan query parameter dengan kata kunci: {search}"
            return Response(response)
 
        # Respon default untuk daftar film
        response = '{ "movies": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }'
        return HttpResponse(response)
    elif request.method == 'POST':
        body = request.data
        response = {
            "message": "Data movie berhasil ditambahkan.",
            "data": body
        }
        return Response(response)
    elif request.method == 'PUT':
        content_type = request.headers['content-type']
        return Response(content_type)

Anda cukup fokus pada bagian GET. Return yang sebelumnya Response diubah menjadi HttpResponse. Selain HttpResponse, kita juga dapat menggunakan objek response lainnya seperti FileResponse.

Ketika diuji dengan cURL, hasilnya akan seperti berikut.

Sebelumnya, ketika mengirimkan HTTP request dengan method GET response yang diberikan dalam bentuk JSON, sekarang response-nya dalam format text/html. Selain bisa mengubah response body, kita juga dapat mengubah header. Yuk kita lanjut ke materi berikutnya!

Response Header

Di contoh HTTP request sebelumnya, Anda dapat melihat response headernya seperti berikut.

Di dalam response header tersebut terdapat Content-Type dengan nilai text/html. Seperti yang Anda ketahui, response atau data yang dikirimkan server ke client tak hanya berformat HTML saja, tetapi juga dapat dalam bentuk JSON. Untuk mengubahnya menjadi JSON, Anda harus mengubah Content-Type menjadi JSON.

Bagaimana caranya? Anda dapat melakukan itu dengan menuliskan kode seperti berikut.

@csrf_exempt
def movies(request):
    if request.method == 'GET':
        search = request.GET.get('search')
        if search:
            # Respon untuk pencarian film
            response = f"Mencari movies menggunakan query parameter dengan kata kunci: {search}"
            return HttpResponse(response)
 
        # Respon default untuk daftar film
        response = HttpResponse()
        response.content = '{ "movies": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }'
        response["Content-Type"] = "application/json"
        return response
    elif request.method == 'POST':
        body = request.body
        data_decode = body.decode('UTF-8')
        response = f"Data movie {data_decode} berhasil ditambahkan."
        return HttpResponse(response)
    elif request.method == 'PUT':
        content_type = request.headers['content-type']
        return HttpResponse(content_type)
 
    # Mengembalikan respon jika metode HTTP tidak didukung
    response = f"Halaman tidak dapat diakses menggunakan {request.method} request"
    return HttpResponse(response)

HttpResponse diubah menjadi variabel response agar response header dapat dimanipulasi dengan mudah. Kemudian, kita menggunakan atribut content untuk memberikan nilai pada response body. Karena objek HttpResponse dapat berperilaku layaknya dictionary, kita dapat mengakses dan menetapkan nilai Content-Type di objek HttpResponse.

Ketika kita uji dengan cURL, hasilnya akan tampak seperti berikut.

Content-Type di dalam response header telah berubah menjadi application/json. Artinya, kita telah berhasil mengubah response header. Selain mengubah response header yang sudah ada, kita juga dapat menambahkan header baru seperti berikut ini.

@csrf_exempt
def movies(request):
    if request.method == 'GET':
        search = request.GET.get('search')
        if search:
            # Respon untuk pencarian film
            response = f"Mencari movies menggunakan query parameter dengan kata kunci: {search}"
            return HttpResponse(response)
 
        # Respon default untuk daftar film
        response = HttpResponse()
        response.content = '{ "movies": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }'
        response["Content-Type"] = "application/json"
        response['Powered-By'] = 'Django'
        return response
    elif request.method == 'POST':
        body = request.body
        data_decode = body.decode('UTF-8')
        response = f"Data movie {data_decode} berhasil ditambahkan."
        return HttpResponse(response)
    elif request.method == 'PUT':
        content_type = request.headers['content-type']
        return HttpResponse(content_type)
 
    # Mengembalikan respon jika metode HTTP tidak didukung
    response = f"Halaman tidak dapat diakses menggunakan {request.method} request"
    return HttpResponse(response)

Sama seperti Content-Type, untuk menambahkan header baru, tuliskan nama key-nya di variabel response, layaknya dictionary. Nama key dari header baru tersebut adalah Powered-By dengan nilai Django. Di dalam response header, terdapat status code. Status code yang ada di header juga dapat kita ubah, penasaran? Ayo kita simak di materi selanjutnya.

Sebelumnya, Anda sudah berhasil mengubah respon body. Selain itu, Anda dapat mengubah header respons di REST Framework. Misalnya, untuk mengubah header respon pada request GET berikut.

@api_view ([ 'GET' , 'POST' , 'PUT' ])  
film definisi ( permintaan ):
    jika request.method == ' GET ' : 
        pencarian = permintaan_parameter_kueri dapatkan ( "pencarian" )
        jika pencarian :
            # Respon untuk pencarian film
            respon = f "Mencari film menggunakan parameter query dengan kata kunci: {search}"
            kembalikan Respons ( respon )
        # Respon default untuk daftar film
        respons = Respons () 
        merespons . data = '{ "film": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }' 
        tipe_konten respon = "teks/html" 
        balasan
    jika request.method == ' POST ' : 
        isi = data permintaan
        respons = { 
            "message" : "Data film berhasil ditambahkan." , 
            "data" : isi
        }
        kembalikan Respons ( respon )
    jika metode permintaan == 'PUT' : 
        content_type = request.headers [ 'content- type ' ]
        kembalikan Respons ( tipe_konten )

Perhatikan kode yang ada di bagian.

respons = Respons () 
tanggapan . data = '{ "film": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }' 
respons.content_type = " text/html " 
balasan

Untuk mengubah header respon seperti kode status dan content_type, Anda dapat menggunakan atribut status_code dari objek Response dan memberikan nilai.

Ketika dijalankan, hasilnya akan seperti berikut.

Bagus , header respons telah berhasil diubah. Selain mengubah header respons, kita juga dapat mengubah kode status respons.

Response Status Code

Ketika kita mengirimkan HTTP request POST untuk menambahkan data movie baru seperti berikut, status code yang ada di response header bernilai 200 (OK).

Namun, status code tersebut tidaklah tepat karena ketika mengirimkan data baru menggunakan HTTP request, status code yang dikembalikan seharusnya adalah 201 (Created).

Catatan:
Untuk lebih detail mengenai status code, Anda dapat mengunjungi halaman dokumentasi terkait status code dari MDN.

Meskipun pada contoh kita tidak benar-benar menambahkan data baru, kita akan mengubah status code 200 menjadi 201. Caranya adalah dengan menambahkan status pada HttpResponse seperti berikut.

@csrf_exempt
def movies(request):
    if request.method == 'GET':
        search = request.GET.get('search')
        if search:
            # Respon untuk pencarian film
            response = f"Mencari movies menggunakan query parameter dengan kata kunci: {search}"
            return HttpResponse(response)
 
        # Respon default untuk daftar film
        response = HttpResponse()
        response.content = '{ "movies": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }'
        response["Content-Type"] = "application/json"
        response['Powered-By'] = 'Django'
        return response
    elif request.method == 'POST':
        body = request.body
        data_decode = body.decode('UTF-8')
        response = f"Data movie {data_decode} berhasil ditambahkan."
        return HttpResponse(response, status=201)
    elif request.method == 'PUT':
        content_type = request.headers['content-type']
        return HttpResponse(content_type)
 
    # Mengembalikan respon jika metode HTTP tidak didukung
    response = f"Halaman tidak dapat diakses menggunakan {request.method} request"
    return HttpResponse(response)

Cukup fokuskan perhatian Anda pada bagian kode berikut. Untuk mengubah status code, cukup tuliskan status=201 di dalam HttpResponse.

elif request.method == 'POST':
        body = request.body
        data_decode = body.decode('UTF-8')
        response = f"Data movie {data_decode} berhasil ditambahkan."
        return HttpResponse(response, status=201)

Jika dijalankan, hasilnya akan tampak seperti berikut.

Status code sudah berhasil diubah menjadi 201 (Created), good job! Pengetahuan ini akan menjadi bekal Anda untuk memahami materi selanjutnya.

Response Status Code

Status code di REST Framework masih sama seperti di Django. Perhatikan kode berikut ini.

@api_view(['GET', 'POST', 'PUT'])(['GET', 'POST', 'PUT'])
def movies(request):
    if request.method == 'GET':
        search = request.query_params.get("search")
        if search:
            # Respon untuk pencarian film
            response = f"Mencari movies menggunakan query parameter dengan kata kunci: {search}"
            return Response(response)
        # Respon default untuk daftar film
        response = Response()
        response.data = '{ "movies": ["Agak Laen", "Warkop DKI Reborn Part 1", "Pengabdi Setan 2", "Dilan", "Sewu Dino"] }'
        response.status_code = 200
        response.content_type = "text/html"
        return response
    elif request.method == 'POST':
        body = request.data
        response = {
            "message": "Data movie berhasil ditambahkan.",
            "data": body
        }
        return Response(response, status=201)
    elif request.method == 'PUT':
        content_type = request.headers['content-type']
        return Response(content_type)

Perhatikan pada bagian method POST. Mengubah response code dapat dilakukan dengan cara menuliskan argumen status di dalam objek Response.

kembalikan Respons(respons, status=201) Response(response, status=201)

Ketika diuji dengan cURL, status code yang sebelumnya bernilai 200 akan berubah menjadi 201.

Cukup mudah untuk mengubah status code di response, kan? Saat ini, Anda sudah mengetahui bagaimana memodifikasi response di REST Framework. Pengetahuan ini akan menjadi bekal untuk menjelajahi materi selanjutnya.

Bersambung ke:

Search This Blog

Back-End Python Developer