REST API

Trainer Name:
Sandhya K

Mentor:
Mr. Harisha A M
REST API

REST API
Class 1 : REST API-INTRODUCTION
End user → Gets all required information.
Developer → Designs app to access data in database via APIs.
API → [Application Programming Interface] connects with database
to retrieve required information.
Database → Offers third party services.

APIs are a set of functions and procedures which allow for the creation of
applications that access data and features of other applications and services.

Purpose : Interoperability

Page No.1
REST API

CRUD operations and HTTP verbs:

1. GET → Getting information/resource →Retrieve
2. POST → Create a new resource → Create
3. PUT → To update resource → Update
4. PATCH → Partial updation → Update
5. DELETE → Delete a resource → Delete

DUMPS AND LOADS:

Python provides a built in package called json that is used to work
with JSON data. And this package includes the methods like
dumps and loads.
Python dictionary→JSON [Javascript object notation]→dumps()
JSON→Python dictionary→loads()
Ex 1:

OUTPUT:
{"name": "Harish", "marks": 99}
<class 'str'>

Page No.2
REST API

Ex 2:

OUTPUT:
{'name': 'Harish', 'marks': 99}
<class 'dict'>

django-admin startproject withoutrest

cd withoutrest
py [Link] startapp myApp
In [Link] add the application

[Link]
from [Link] import render
from [Link] import HttpResponse,JsonResponse
import json
def emp_data_view(request):
emp_data={'eno':100,'ename':'Harish','esal':100000}
response='<h1>Employee Num:{}<br> Employee Name:{} <br> Employee
Sal:{}</h1>'.format(emp_data['eno'],emp_data['ename'],emp_data['esa
l']) return HttpResponse(response)
def emp_json_data_view1(request):
emp_data={'eno':200,'ename':'Girish','esal':50000}
json_data=[Link](emp_data)
return HttpResponse(json_data,content_type='application/json')
def emp_json_data_view2(request):
emp_data={'eno':300,'ename':'Satish','esal':25000}
return JsonResponse(emp_data)

Page No.3
REST API

[Link]
from [Link] import admin
from [Link] import path
from [Link] import *
urlpatterns = [
path('admin/', [Link]),
path('response1/',emp_data_view),
path('response2/',emp_json_data_view1),
path('response3/',emp_json_data_view2)
]

Communication of Django with partner applications

To send http request from a python application we use a module called requests.
To install → pip install requests

Page No.4
REST API

Class 2 : Communication with 3rd party application

1. Create a file inside project withoutrest(project level) [Link]
2. To send request from python application we need requests module.
To install-pip install requests
Cmd prompt1 : Run django server
Cmd prompt2 : py [Link] at project level
[Link]
from [Link] import admin
from [Link] import path
from [Link] import *
urlpatterns =[
path('admin/', [Link]),
path('response1/',emp_data_view),
path('response2/',emp_json_data_view1),
path('response3/',emp_json_data_view2)
]
[Link]
from [Link] import render
from [Link] import HttpResponse,JsonResponse
import json

def emp_data_view(request):
emp_data={'eno':100,'ename':'Harish','esal':60000}
response='<h1>Employee Num:{}<br> Employee Name:{} <br> Employee
Sal:{}</h1>'.format(emp_data['eno'],emp_data['ename'],emp_data['esa
l'])
return HttpResponse(response)

Page No.5
REST API

def emp_json_data_view1(request):
emp_data={'eno':200,'ename':'Girish','esal':70000}
json_data=[Link](emp_data)
return HttpResponse(json_data,content_type='application/json')
def emp_json_data_view2(request):
emp_data={'eno':300,'ename':'Ramesh','esal':80000}
return JsonResponse(emp_data)
[Link][At project level]
import requests
BASE_URL='[Link]
ENDPOINT='response3'
#BASE_URL+ENDPOINT='[Link]
#[Link]
response=[Link](BASE_URL+ENDPOINT)
#respnose is indexable
print(response)
data=[Link]() #data is indexable
print("Data given by Django application")
print('-'*40)
print("Employee Number=",data['eno'])
print("Employee Name=",data['ename'])
print("Employee Salary=",data['esal'])
print(type(data))

Cmd prompt1:Run django server

Cmd propt2:py [Link] at project level
<Response [200]>
Data given by Django application

Employee Number= 300

Employee Name= Ramesh
Employee Salary= 80000
<class 'dict'>

Page No.6
REST API

Class Based views for json response

[Link]
import requests
BASE_URL='[Link]
ENDPOINT='response1'
#BASE_URL+ENDPOINT='[Link]
8000/response3
response=[Link](BASE_URL+ENDPOINT)
#respnose is indexable
print(response)
data=[Link]()#data is indexable
print("Data given by Django application")
print('-'*40)
print("Employee Number=",data['eno'])
print("Employee Name=",data['ename'])
print("Employee Salary=",data['esal'])
print(type(data))
[Link]
from [Link] import render
from [Link] import View
from [Link] import JsonResponse
class CBV(View):
def get(self,*args,**kwargs):
emp_data={'eno':100,'ename':'Harish','esal':60000}
return JsonResponse(emp_data)
[Link]
from [Link] import admin
from [Link] import path
from [Link] import *
urlpatterns =[
path('admin/', [Link]),
path('response1/',CBV.as_view())
]

Page No.7
REST API

[Link]
from [Link] import admin
from [Link] import path
from [Link] import *
urlpatterns =[
path('admin/', [Link]),
path('cbvresponse/',CBV.as_view())
]
[Link]
from [Link] import render
from [Link] import HttpResponse,JsonResponse
import json
from [Link] import View
class CBV(View):
def get(self,*args,**kwargs):
json_data=[Link]({'msg':'get method'})
return HttpResponse(json_data,content_type="application/json")
def post(self,request,*args,**kwargs):
json_data=[Link]({'msg':'post method'})
return HttpResponse(json_data,content_type="application/json")
def put(self,request,*args,**kwargs):
json_data=[Link]({'msg':'put method'})
return HttpResponse(json_data,content_type="application/json")
[Link]
import requests
BASE_URL='[Link]
ENDPOINT='cbvresponse/'
response=[Link](BASE_URL+ENDPOINT) #get put post etc
print(response) #<Response [200]>
#response is not indexable
data=[Link]()
print(data)

Page No.8
REST API

If we execute the above code we get the following error

(CSRF cookie not set.):
To avoid this error,Comment the following line from [Link]
MIDDLEWARE = [
'[Link]',
'[Link]',
'[Link]',
# '[Link]',
'[Link]',
'[Link]',
'[Link]',
]
Note
#*args==>variable length args
#**kwargs==>key word args
def f(*args):
print(args)
f()
f(10,20)#These data gets converted into tuple
f(10,20,30)
o/p
()
(10, 20)
(10, 20, 30)
#*args==>variable length args
#**kwargs==>key word args
def f(**kwargs):
print(kwargs)
f(name="Harish",id=100)
#All the values would be converted into dict
{'name': 'Harish', 'id': 100}

Page No.9
REST API

Class 3 : CRUD using web api without REST framework

[Link]→Add the application
[Link]
from [Link] import models
class Employee([Link]):
eno=[Link]()
ename=[Link](max_length=40)
esal=[Link]()
eaddr=[Link](max_length=100)
def __str__(self):
return [Link]
[Link]
from [Link] import admin
from [Link] import Employee
class EmployeeAdmin([Link]):
l=['id','eno','ename','esal','eaddr']
[Link](Employee,EmployeeAdmin)

Perform migration,create super user,run server and add records in database.

Retrieve operation: Get the information based on id
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import HttpResponse
import json
from [Link] import View
class EmployeeDetails(View):
def get(self,request,*args,**kwargs):
emp=[Link](id=1)
emp_data={'eno':[Link],'ename':[Link],'esal':[Link],'eaddr'
:
[Link]}
json_data=[Link](emp_data)
return HttpResponse(json_data,content_type="application/json")

Page No.10
REST API

[Link]
from [Link] import admin
from [Link] import path
from [Link] import EmployeeDetails
urlpatterns = [
path('admin/', [Link]),
path('api/',EmployeeDetails.as_view())
]
At project level create [Link]
[Link]
import requests
BASE_URL='[Link]
ENDPOINT='api/'
def get_resource():
resp=[Link](BASE_URL+ENDPOINT)
print(resp.status_code)
print([Link]())

get_resource()

Status Codes

Represents status of response

1XX ➔ 100-199[Informational] Ex:Don’t close the browser
2XX ➔ 200-299[Successful]
3XX ➔ 300-399[Redirectional]
4XX ➔ 400-499[Page not found]
5XX ➔ 500-599[Server error]

Page No.11
REST API

Getting id from user and display the details

[Link]
from [Link] import render
from [Link] import Employee
from [Link] import HttpResponse
from [Link] import View
import json
class EmployeeDetails(View):
def get(self,request,id,*args,**kwargs):
emp=[Link](id=id)
emp_data={'eno':[Link],'ename':[Link],'esal':[Link],'eaddr':
[Link]}
json_data=[Link](emp_data)
return HttpResponse(json_data,content_type="application/json")
[Link]
from [Link] import admin
from [Link] import url
from [Link] import EmployeeDetails
urlpatterns = [
url('admin/', [Link]),
url('api/(?P<id>\d+)/$',EmployeeDetails.as_view())
]
[Link]
import requests
BASE_URL='[Link]
ENDPOINT='api/'
def get_resource(id):
resp=[Link](BASE_URL+ENDPOINT+id+'/')
#[Link]
print(resp.status_code)
print([Link]())
id=input("Enter id:")
get_resource(id)

Page No.12
REST API

[Link]
from [Link] import models
class Employee([Link]):
eno=[Link]()
ename=[Link](max_length=40)
esal=[Link]()
eaddr=[Link](max_length=100)
def __str__(self):
return [Link]
[Link]
from [Link] import admin
from [Link] import Employee
class EmployeeAdmin([Link]):
l=['id','eno','ename','esal','eaddr']
[Link](Employee,EmployeeAdmin)
cmd prompt1 → run django server
cmd prompt2 → run python application

Page No.13
REST API

Class 4 : SERIALIZATION
Converting python dictionary to json obeject.
Converting an employee record into a dictionary is easy.
If it is query set,If we use [Link]()
Gives many [Link] them into dictionary is very difficult.
To overcome this problem,we use a module called serializers.
Serializers → django inbuilt method that contains a method called serialize
Using serialize we can convert query set into json very easily.
json_data=[Link](‘json’,qs)
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import HttpResponse
from [Link] import View
from [Link] import serialize
import json
class EmployeeDetails(View):
def get(self,request,id,*args,**kwargs):
emp=[Link](id=id)
json_data=serialize('json',[emp]) #only one record
return HttpResponse(json_data,content_type="application/json")
py [Link]

Extracting only the specified fields

from [Link] import render
from [Link] import Employee
from [Link] import HttpResponse
from [Link] import View
from [Link] import serialize
import json

Page No.14
REST API

class EmployeeDetails(View):
def get(self,request,id,*args,**kwargs):
emp=[Link](id=id)
json_data=serialize('json',[emp],fields=('eno','ename')) #only one record
return HttpResponse(json_data,content_type="application/json")
CRUD operation:1 → Retrieve based on provided id
CRUD operation:2 → Retrieve all records
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import HttpResponse
from [Link] import View
from [Link] import serialize
import json
class EmployeeDetails(View):
def get(self,request,*args,**kwargs):
emp=[Link]()
json_data=serialize('json',emp) #only one record
return HttpResponse(json_data,content_type="application/json")
[Link]
from [Link] import admin
from [Link] import url
from [Link] import EmployeeDetails
urlpatterns = [
url('admin/', [Link]),
url('api/$',EmployeeDetails.as_view())
]
[Link]
import requests
BASE_URL='[Link]
ENDPOINT='api/'
def get_resource():
resp=[Link](BASE_URL+ENDPOINT)

Page No.15
REST API

#[Link]
print(resp.status_code)
print([Link]())
get_resource()
Removing Extra information
[{'model': '[Link]', 'pk': 1, 'fields': {'eno': 101, 'ename': 'shreekanth',
'esal': 10000.0,……}]
Step 1:Convert json data into dict by using loads()
Step 2:For each object in dict,extract the required fields
json_data=serialize(‘json’,qs)
pdict=[Link](json_data) # Step 1
result=[] #to hold python data
for ob in pdict:
emp_data=ob[‘fields’] #step 2
[Link](emp_data)
json_data=[Link](result)
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import HttpResponse
from [Link] import View
from [Link] import serialize
import json

class EmployeeDetails(View):
def get(self,request,*args,**kwargs):
emp=[Link]()
json_data=serialize('json',emp)
p_dict=[Link](json_data)
result=[]
for ob in p_dict:
emp_data=ob['fields']
[Link](emp_data)
json_data=[Link](result)
return HttpResponse(json_data,content_type="application/json")

Page No.16
REST API

Class 5 and 6 : Extra Information

[Link] extra information
To avoid extra information at id level,wrt server,we need the previous
functionality one more time, Hence we use mixin to generalize the
functionality.[Customization purpose]
[Link]
import requests
BASE_URL='[Link]
ENDPOINT='api/'
def get_resource1():
resp=[Link](BASE_URL+ENDPOINT)
#[Link]
print(resp.status_code)
print([Link]())
def get_resource2(id):
resp=[Link](BASE_URL+ENDPOINT+id+'/')
print(resp.status_code)
print([Link]())
print("Enter 1-->to display all records 2-->to display a particular record")
ch=int(input("Enter your choice"))
if ch==1:
get_resource1()
if ch==2:
id=input("Enter id")
get_resource2(id)
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import HttpResponse
from [Link] import View
from [Link] import SerializeMixin
import json

Page No.17
REST API

class EmployeeDetails(SerializeMixin,View):
def get(self,request,id,*args,**kwargs):
emp=[Link](id=id)
json_data=[Link]([emp])
return HttpResponse(json_data,content_type='application/json')
class EmployeeList(SerializeMixin,View):
def get(self,request,*args,**kwargs):
qs=[Link]() json_data=[Link](qs)
return HttpResponse(json_data,content_type='application/json')
myApp/[Link]
from [Link] import serialize
import json
class SerializeMixin(object):
def fun(self,qs):
json_data=serialize('json',qs)
p_dict=[Link](json_data)
result=[]
for ob in p_dict:
emp_data=ob['fields']
[Link](emp_data)
json_data=[Link](result)
return json_data
[Link]
from [Link] import admin
from [Link] import url
from [Link] import *
urlpatterns = [
url('admin/', [Link]),
url('api/$',EmployeeList.as_view()),
url('api/(?P<id>\d+)/$',EmployeeDetails.as_view())
]

Page No.18
REST API

Exception Handling
It is not recommended to display the error information directly to the
partner application, such errors must be handled.
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import HttpResponse
from [Link] import View
from [Link] import SerializeMixin
import json
class EmployeeDetails(SerializeMixin,View):
def get(self,request,id,*args,**kwargs):
try:
emp=[Link](id=id)
except:
json_data=[Link]({'msg':'The requested resource is
unavailable'})
else:
json_data=[Link]([emp])
return HttpResponse(json_data,content_type='application/json')
class EmployeeList(SerializeMixin,View):
def get(self,request,*args,**kwargs):
qs=[Link]()
json_data=[Link](qs)
return HttpResponse(json_data,content_type='application/json')
Assuming that our [Link] does not handle the exception,then we can also
handle the exception as shown below:
import requests
BASE_URL='[Link]
ENDPOINT='api/'
def get_resource1():
resp=[Link](BASE_URL+ENDPOINT)
#[Link]

Page No.19
REST API

print(resp.status_code)
print([Link]())
def get_resource2(id):
resp=[Link](BASE_URL+ENDPOINT+id+'/')
if resp.status_code not in range(200,300):#successfull
print("Something went wrong")
else:
print([Link]())
print("Enter 1-->to display all records 2-->to display a particular record")
ch=int(input("Enter your choice"))
if ch==1:
get_resource1()
if ch==2:
id=input("Enter id")
get_resource2(id)

Adding status code to the response

[Link]
import requests
BASE_URL='[Link]
ENDPOINT='api/'
def get_resource1():
resp=[Link](BASE_URL+ENDPOINT)
#[Link]
print(resp.status_code)
print([Link]())
def get_resource2(id):
resp=[Link](BASE_URL+ENDPOINT+id+'/')
print([Link]())
print(resp.status_code)print("Enter 1-->to display all records 2-->to
display a particular record")
ch=int(input("Enter your choice"))
if ch==1:
get_resource1()

Page No.20
REST API

if ch==2:
id=input("Enter id")
get_resource2(id)
[Link]
from [Link] import serialize
import json
from [Link] import HttpResponse
class HttpResponseMixin(object):
def render_to_http_response(self,json_data,status=200):
#default status=200
return HttpResponse(json_data,content_type='application/json',
status=status)
class SerializeMixin(object):
def fun(self,qs):
json_data=serialize('json',qs)
p_dict=[Link](json_data)
result=[]
for ob in p_dict:
emp_data=ob['fields']
[Link](emp_data)
json_data=[Link](result)
return json_data
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import HttpResponse
from [Link] import View
from [Link] import SerializeMixin,HttpResponseMixin
import json
class EmployeeDetails(SerializeMixin,HttpResponseMixin,View):
def get(self,request,id,*args,**kwargs):
try:
emp=[Link](id=id)

Page No.21
REST API

except:
json_data=[Link]({'msg':'The requested resource is
unavailable'})
return self.render_to_http_response(json_data,status=404)
else:
json_data=[Link]([emp])
return self.render_to_http_response(json_data)
class EmployeeList(SerializeMixin,View):
def get(self,request,*args,**kwargs):
qs=[Link]()
json_data=[Link](qs)
return HttpResponse(json_data,content_type='application/json')
[Link]
from [Link] import admin
from [Link] import url
from [Link] import *
urlpatterns = [
url('admin/', [Link]),
url('api/$',EmployeeList.as_view()),
url('api/(?P<id>\d+)/$',EmployeeDetails.as_view())
]

It is possible to dump db data to a console

py [Link] dumpdata [Link]→provides employee data to the
console json form
py [Link] dumpdata [Link] --indent 4
we can print the data in xml format
py [Link] dumpdata [Link] --format xml --indent 4
we can save the data in a file say [Link]
[Link] dumpdata [Link] --format xml>[Link] --indent 4

Page No.22
REST API

Class 7: Single endpoint for all operations

url('api1/',[Link].as_view()),
url('api2/(?P<id>\d+)/$',[Link].as_view())
All these methods use upto 2 endpoints but we are supposed to use only
1 end point to perform all the CURD operation with a single api call
SINGLE API FOR ALL CRUD METHODS
[Link]
from [Link] import models
class Student([Link]):
name=[Link](max_length=30)
rollno=[Link]()
marks=[Link]()
address=[Link](max_length=100)
def __str__(self):
return [Link]
[Link]
from [Link] import admin
from [Link] import Student
# Register your models here.
class StudentAdmin([Link]):
l=['id','name','rollno','marks','address']
[Link](Student,StudentAdmin)
[Link]
from django import forms
from [Link] import Student
class StudentForm([Link]):
def clean_marks(self):
m=self.cleaned_data['marks'] if m<35:
raise Exception("Min marks must be 35 ")
return m
class Meta:
model=Student
fields="__all__"

Page No.23
REST API

[Link]
from [Link] import serialize
from [Link] import HttpResponse
import json
class SerilizeMixin(object):
def fun(self,qs):
json_data=serialize('json',qs)
pdata=[Link](json_data)
final_list=[]
for ob in pdata:
required_info=ob['fields']
final_list.append(required_info)
json_data=[Link](final_list)
return json_data
class HttpResponseMixin(object):
def render_to_http_response(self,json_data,status=200):
return HttpResponse(json_data,content_type='application/json',
status=status)
myApp/[Link]
import json
def is_json(data):
try:
p_data=[Link](data)
valid=True
except Exception:
valid=False
return valid
[Link]
from [Link] import admin
from [Link] import url
from myApp import views
urlpatterns = [
url('admin/', [Link]),
url('api/',[Link].as_view()) ]

Page No.24
REST API

[Link]
from [Link] import render
from [Link] import Student
from [Link] import StudentForm
from [Link] import View
from [Link] import csrf_exempt
from [Link] import method_decorator
from [Link] import is_json
from [Link] import SerilizeMixin,HttpResponseMixin
import json
@method_decorator(csrf_exempt,name='dispatch')
class StudentCBV(View,HttpResponseMixin,SerilizeMixin):
def get_rec_by_id(self,id):
try:
stud=[Link](id=id)
except Exception:
stud=None
return stud
def get(self,request,*args,**kwargs):
data=[Link] #data is a json data it may be empty or it may contain id
valid=is_json(data)
if not valid:
json_data=[Link]({'msg':'invalid'})
return self.render_to_http_response(json_data,status=404)
pdata=[Link](data)
id=[Link]('id',None)
if id is not None:
stud=self.get_rec_by_id(id)
if stud is None:
json_data=[Link]({'msg':'invalid record'})
return self.render_to_http_response(json_data,status=404)
json_data=[Link]([stud])
return self.render_to_http_response(json_data)
qs=[Link]() # if id is None

Page No.25
REST API

json_data=[Link](qs)
return self.render_to_http_response(json_data)
def post(self,request,*args,**kwargs):
data=[Link]
valid=is_json(data)
if not valid:
json_data=[Link]({'msg':'invalid'})
return self.render_to_http_response(json_data,status=404)
p_data=[Link](data)
form=StudentForm(p_data)
if form.is_valid():
[Link](commit=True)
json_data=[Link]({'msg':'Successfully created the record'})
return self.render_to_http_response(json_data)
if [Link]():
json_data=[Link]({'msg':'Form submission error'})
return self.render_to_http_response(json_data,status=404)
def put(self,request,*args,**kwargs):
data=[Link]
valid=is_json(data)
if not valid:
json_data=[Link]({'msg':'Not a json data'})
return self.render_to_http_response(json_data,status=404)
provided_data=[Link](data)
id=provided_data.get('id',None)
if id is None:
json_data=[Link]({'msg':'invalid id'})
return self.render_to_http_response(json_data,status=404)
stud=self.get_rec_by_id(id)
if stud is None:
json_data=[Link]({'msg':'invalid record'})
return self.render_to_http_response(json_data,status=404)
original_data={'name':[Link],'rollno':[Link],'marks':[Link],
'address':[Link]}

Page No.26
REST API

original_data.update(provided_data)
form=StudentForm(original_data,instance=stud)
if form.is_valid():
[Link](commit=True)
json_data=[Link]({'msg':'Updation is successful'})
return self.render_to_http_response(json_data)
if [Link]:
json_data=[Link]({'msg':'Error in form submission'})
return self.render_to_http_response(json_data,status=404)
def delete(self,request,*args,**kwargs):
data=[Link]
valid=is_json(data)
if not valid:
json_data=[Link]({'msg':'Not a json data'})
return self.render_to_http_response(json_data,status=404)
provided_data=[Link](data)
id=provided_data.get('id',None)
if id is None:
json_data=[Link]({'msg':'Invalid id'})
return self.render_to_http_response(json_data,status=404)
stud=self.get_rec_by_id(id)
if stud is None:
json_data=[Link]({'msg':'invalid record'})
return self.render_to_http_response(json_data,status=404)
status,item=[Link]()
if status==1:
print("Deleted successfully")
else:
print("Deletion error")

Page No.27
REST API

At project level [Link]

import json
import requests
BASE_URL='[Link]
ENDPOINT='api/'
def get_resource(id=None):
data={} #you need all records
if id is not None:
data={'id':id} # A record with a particular id
response=[Link](BASE_URL+ENDPOINT,data=[Link](data))
print(response.status_code)
print([Link]())

def create_resource():
stud_data={'name':'Anand','rollno':201,'marks':88,'address':'Delhi'}
response=[Link](BASE_URL+ENDPOINT,data=[Link](stud_d
ata))
print(response.status_code)
print([Link]())

def update_resource(id):
stud_data={'id':id,'name':'New user','marks':88,'address':'
Unknown place'}
response=[Link](BASE_URL+ENDPOINT,data=[Link](
stud_data))
print(response.status_code)
print([Link]())

def delete_resource(id):
data={'id':id}
response=[Link](BASE_URL+ENDPOINT,data=[Link]
(data))
print(response.status_code)
print([Link]())

Page No.28
REST API

print("Enter 1--->To retrive the records \n 2--->To create a new record

3--->To update a record \n 4---->To delete a record\n")
print("Enter your choice")
ch=int(input())
if ch==1:
get_resource()
elif ch==2:
create_resource()
elif ch==3:
id=input("Enter id")
update_resource(id)
elif ch==4:
id=input("Enter id")
delete_resource(id)

Page No.29
REST API

Class 8: Developing web API’s by using third party Django Rest

Framework
The browsable API ensures that all the endpoints you create in your API are
able to respond both with machine readable (ie JSON) and human readable
(ie HTML) representations.
This feature is used to generate HTML o/p for different [Link] facilitates
interaction with rest web services through any web browser.
It helps us to use web browser to surf through the API and can make different
HTTP requests.
Specialty of DRF
[Link] provides browsable apis
[Link] token authentication
[Link] built serializers that support ORM and non-ORM
[Link] documentation
[Link] by Mozilla,redhat
Installation
1. pip install djangorestframework
2. pip install markdown # used for browsable apis
3. pip install django-filter # filtering support
4. pip freeze>[Link]
[Link]
INSTALLED_APPS=[
…
‘myApp’,
‘rest_framework’
]

from [Link] import path,include

Mapping django’s url pattern to rest_framework’s url pattern
path(‘api/’,include(‘rest_framework.urls’))

Page No.30
REST API

DRF SERIALIZERS
Perform three activities
1. Serialization
2. Deserialization
3. Validation
Note:
class StudentForm([Link]):
sname=[Link]()
class StudentSerializer([Link]):
sname= [Link](max_length)
class StudentSerializer([Link]):
class Meta:
model=Student
fields=”__all__”

Create Project:
→ cmd prompt: cd DjangoApplications
→ djang0-admin startproject withrest1
→ cd withrest1
→ py [Link] startapp myApp
[Link]:
‘myAPP’
‘rest_framework’
Urlspatterns=[
Path(‘api-auth/’,include(‘rest_framework.urls))
]
[Link]
from [Link] import admin
from [Link] import path,include
urlpatterns = [
path('admin/', [Link]),
path('api-auth/',include('rest_framework.urls'))
]

Page No.31
REST API

[Link]
from [Link] import models
class Employee([Link]):
eno=[Link]()
ename=[Link](max_length=60)
esal=[Link]()
eaddr=[Link](max_length=100)
[Link]
from [Link] import admin
from [Link] import Employee
class EmployeeAdmin([Link]):
l=['id','eno','ename','esal','eaddr']
[Link](Employee,EmployeeAdmin)
myApp/[Link]
from rest_framework import serializers
class EmployeeSerializer([Link]):
eno=[Link]()
ename=[Link](max_length=60)
esal=[Link]()
eaddr=[Link](max_length=100)
makemigrations,migrate,create superuser and runserver

The process of converting complex types(query set or model instance) to

dict[python native form]→Serialization
Ex:If we convert an employee object [querySet/model instance] to dict,then
we can easily convert into json form
Py [Link] shell
>>>from [Link] import Employee
>>> from [Link] import EmployeeSerializer
>>> emp=[Link](id=1)
>>> from [Link] import Employee
>>> from [Link] import EmployeeSerializer
>>> emp=[Link](id=1)

Page No.32
REST API

>>> emp
<Employee: Employee object (1)>
>>> [Link]
101
>>> [Link]
'shreekanth'
>>> eserializer=EmployeeSerializer(emp)
>>> [Link]
{'eno': 101, 'ename': 'shreekanth', 'esal': 70000.0, 'eaddr': 'bangalore'}
>>> type(emp)
<class '[Link]'>
>>> type(eserializer)
<class '[Link]'>

Converting python native type(dict) to Json data

Note
Open pycharm: type this code and run
class One:
def fun(self):
print("inside fun")

One().fun()

o/p: Inside fun #[without creating the object we call the method]

>>> from rest_framework.renderers import JSONRenderer

>>> json_data=JSONRenderer().render([Link])
>>> json_data
b'{"eno":101,"ename":"shreekanth","esal":70000.0,"eaddr":"bangalore"}'

>>> from rest_framework.renderers import JSONRenderer

>>> from [Link] import Employee
>>> from [Link] import EmployeeSerializer
>>> qs=[Link]()

Page No.33
REST API

>>> type(qs)
<class '[Link]'>
>>> eserializer=EmployeeSerializer(qs,many=True)
>>> type(eserializer)
<class 'rest_framework.[Link]'>
>>> eserializer
EmployeeSerializer(<QuerySet [<Employee: Employee object (1)>,
<Employee:
Employee object (2)>, <Employee: Employee object (3)>, <Employee:
Employee object (4)>]>, many=True):
eno = IntegerField() ename = CharField(max_length=60)
esal = FloatField()
eaddr = CharField(max_length=100)
>>> [Link]
[OrderedDict([('eno', 101), ('ename', 'shreekanth'), ('esal', 70000.0), ('eaddr',
'bangalore')]), OrderedDict([('eno', 102), ('ename', 'shreenath'), ('esal',
10000.0),
('eaddr', 'Mumbai')]), OrderedDict([('eno', 103), ('ename', 'shreya'), ('esal',
30000.0), ('eaddr', 'Delhi')]), OrderedDict([('eno', 104), ('ename', 'Michael
john'), ('esal', 50000.0), ('eaddr', 'Delhi')])]
>>> from rest_framework.renderers import JSONRenderer
>>> json_data=JSONRenderer().render([Link])
>>> json_data
b'[{"eno":101,"ename":"shreekanth","esal":70000.0,"eaddr":"bangalore"},{"
eno":102,"ename":"shreenath","esal":10000.0,"eaddr":"Mumbai"},{"eno":1
03,"ename":"shreya","esal":30000.0,"eaddr":"Delhi"},{"eno":104,"ename":"
Michael john","esal":50000.0,"eaddr":"Delhi"}]'

Qs or Model Instance ➔ dict[Serialization] dict ➔ json data

DESERIALIZATION
Json data➔dict➔Db supported types[QS or Model instance]
The process of converting python native type(dict) into Db supported types is
called deserialization

Page No.34
REST API

Ob➔If this object contains a single record then the data type is model
instance
Ob➔If this object contains multiple records then the data type is query set
>>> emp=[Link](id=1)>>> type(emp)
<class '[Link]'>
>>> emp=[Link]()
>>> type(emp)
<class '[Link]'>

Scenario
Json data→dict ➔JSONParser().parse(stream)
Stream is a byte string [b’……..’]
>>> import io
>>> from rest_framework.parsers import JSONParser
>>>
>>> pdata=JSONParser().parse(stream)
>>> pdata
[{'eno': 101, 'ename': 'shreekanth', 'esal': 70000.0, 'eaddr': 'bangalore'},
{'eno': 102, 'ename': 'shreenath', 'esal': 10000.0, 'eaddr': 'Mumbai'}, {'eno':
103, 'ename': 'shreya', 'esal': 30000.0, 'eaddr': 'Delhi'}, {'eno': 104, 'ename':
'Michael john', 'esal': 50000.0, 'eaddr': 'Delhi'}]
>>> stream
<_io.BytesIO object at 0x0000018F9677CE00>
Json_data must be converted into bytes form for processing
parse() is the method of JSONParser class,it converts bytes stream of json
data into python dict.

Post processing step after

serializationjson_data=JSONRenderer().render([Link])
➔converts dict into json data
QS or model instance➔dict[serialization]
Dict➔json string

Page No.35
REST API

Pre processing step before deserialization

pdata=JSONRenderer().render([Link])
→converts json stream into py dict
Json string➔dict→DB supported types
Dict➔DB supported types(deserialization)
render()→dict to json data [post processing after serialization]
parse()→json datastream to dict [pre processing before deserialization]

USE CASE
[Link] APPLICATION NEEDS ALL RECORDS IN JSON FORM
STEP 1:Employee Records[Query set]
STEP 2:Qs is converted into dict[serializat]ion]
STEP 3:dict→json data by using render(){post processing}
o/p➔json data
[Link] APPLICATION IS SENDING JSON DATA TO CREATE NEW EMPLOYEE
ENTRY
STEP 1:collect json data
STEP 2:Json data is converted into dict by using parse(){pre processing}
STEP 3:dict is converted into DB supported types{Deserialization}o/p:Query
set or model instance

UPDATION
For updation we must override a method update for this,we need 2 entities
[Link] instance
[Link] data
We should update the instance with validated data provided by partner
application
[Link]=validated_data.get(‘eno’,[Link])
eno→provided by partner application[[Link]]
if [Link] provides any eno,consider the corresponding value and assign this to
existing [Link][if no eno is provided then consider the current eno]

Page No.36
REST API

[Link]
from [Link] import models
class Employee([Link]):
eno=[Link]()
ename=[Link](max_length=6)
esal=[Link]()
eaddr=[Link](max_length=100)
[Link]
from [Link] import admin
from [Link] import Employee
class EmployeeAdmin([Link]):
l=['id','eno','ename','esal','eaddr']
[Link](Employee,EmployeeAdmin)
[Link]
from rest_framework import serializers
from [Link] import Employee
class EmployeeSerializer([Link]):
def multiples_of_1000(value):
print("validation by validator attribute")
if value%1000!=0:
raise Exception("Emp sal must be multiple of 1000")
def create(self,validated_data):
return [Link](**validated_data)
#validated data containes kye:value pairs
def update(self,instance,validated_data):
[Link]=validated_data.get('eno',[Link])
[Link]=validated_data.get('ename',[Link])
[Link]=validated_data.get('esal',[Link])
[Link]=validated_data.get('eaddr',[Link])
[Link]()
return instance
eno=[Link]() ename=[Link](max_length=6)
esal=[Link](validators=[multiples_of_1000])
eaddr=[Link](max_length=100)

Page No.37
REST API

[Link]
import requests
import json
BASE_URL='[Link]
ENDPOINT='api/'
def get_resource(id=None):
data={}
if id is not None:
data={'id':id}
response=[Link](BASE_URL+ENDPOINT,data=[Link](data))
print(response.status_code)
print([Link]())
def create_resource():
new_emp={'eno':999,'ename':'abhi','esal':200,'eaddr':'Mumbai'}
response=[Link](BASE_URL+ENDPOINT,data=[Link]
(new_emp))
print(response.status_code)
print([Link]())
def update_resource(id):
new_data={'id':id,'esal':100000,'eaddr':'Mysore'}
response=[Link](BASE_URL+ENDPOINT,data=[Link]
(new_data))
print(response.status_code)
print([Link]())
def delete_resource(id):
data={'id':id}
response=[Link](BASE_URL+ENDPOINT,data=[Link](data))
print(response.status_code)
print([Link]())
print("Enter 1--->get a resource\n 2--->create a resource 3-->update resource
4-- ->delete resource")
ch=int(input("Enter your option"))
if ch==1:
get_resource()

Page No.38
REST API

if ch==2:
create_resource()
if ch==3:
id=int(input("Enter id"))
update_resource(id)
if ch==4:
id=int(input("Enter id"))
delete_resource(id)
[Link]
from [Link] import render
from [Link] import View
from rest_framework.parsers import JSONParser
import io
from [Link] import Employee
from [Link] import EmployeeSerializer
from rest_framework.renderers import JSONRenderer
from [Link] import HttpResponse
from [Link] import csrf_exempt
from [Link] import method_decorator
@method_decorator(csrf_exempt,name='dispatch')
class EmployeeCRUDCBV(View):
def get(self,request,*args,**kwargs):
json_data=[Link]
stream=[Link](json_data)
pdata=JSONParser().parse(stream)
id=[Link]('id',None)
if id is not None:
emp=[Link](id=id)
serializer=EmployeeSerializer(emp)
json_data=JSONRenderer().render([Link])
return HttpResponse(json_data,content_type='application/json')
qs=[Link]()
serializer=EmployeeSerializer(qs,many=True)
json_data=JSONRenderer().render([Link])

Page No.39
REST API

return HttpResponse(json_data,content_type='application/json')
def post(self,request,*args,**kwargs):
json_data=[Link]
stream=[Link](json_data)
pdata=JSONParser().parse(stream)
serializer=EmployeeSerializer(data=pdata)
if serializer.is_valid():
[Link]() #internally calls create method_decorator
msg={'msg':'resource created successfully'}
json_data=JSONRenderer().render(msg)
return HttpResponse(json_data,content_type='application/json')
else:
msg={'msg':'error in creation'}
json_data=JSONRenderer().render(msg)
return HttpResponse(json_data,content_type='application/json')
def put(self,request,*args,**kwargs):
json_data=[Link]
stream=[Link](json_data) pdata=JSONParser().parse(stream)
id=[Link]('id')
emp=[Link](id=id)
serializer=EmployeeSerializer(emp,data=pdata,partial=True)
#update emp with data
if serializer.is_valid():
[Link]() #internally calls update method
msg={'msg':'resource updated successfully'}
json_data=JSONRenderer().render(msg)
return HttpResponse(json_data,content_type='application/json')
else:
msg={'msg':'error in updation'}
json_data=JSONRenderer().render(msg)
return HttpResponse(json_data,content_type='application/json')
#by default put() accepts complete data not partial data

Page No.40
REST API

def delete(self,request,*args,**kwargs):
json_data=[Link]
stream=[Link](json_data)
pdata=JSONParser().parse(stream)
id=[Link]('id')
emp=[Link](id=id)
[Link]() msg={'msg':'Resource deleted successfully'}
json_data=JSONRenderer().render(msg)
return HttpResponse(json_data,content_type='application/json')
[Link]
INSTALLED_APPS = [
….
'myApp',
'rest_framework'
]

Validations by using serializers

[Link] level validation
[Link] level validation
[Link] using validators

Field level validation

validate_field_name()
[Link]
from rest_framework import serializers
from [Link] import Employee
class EmployeeSerializer([Link]):
def validate_esal(self,value): #is called by serializers.is_valid()
if value<5000:
raise [Link](“Sal cannot be <5000”)
def create(self,validated_data):
return [Link](**validated_data)
#validated data containes kye:value pairs

Page No.41
REST API

def update(self,instance,validated_data):
[Link]=validated_data.get('eno',[Link])
[Link]=validated_data.get('ename',[Link])
[Link]=validated_data.get('esal',[Link])
[Link]=validated_data.get('eaddr',[Link])
[Link]()
return instance
eno=[Link]()
ename=[Link](max_length=40)
esal=[Link]()
eaddr=[Link](max_length=100)

object level validation:

use the method validate()
[Link]
def validate(self,data):# data total data
ename=[Link](‘ename’)
esal=[Link](‘esal’)
if esal<5000:
raise [Link](“Sal cannot be <5000”)
return data
when is_valid() is called,both field level and object level implementations
get executed.

By using validators
Ename’s max_length=4,
In [Link]
ename=[Link](max_length=6)
[Link]
ename=[Link](max_length=6)
now if we try to create a resource then we get the following error
{'msg': 'error in creation'}
That means max_length is an inbuilt validator
class EmployeeSerializer([Link]):
def multiples_of_1000(value):

Page No.42
REST API

print("validation by validator attribute")

if value%1000!=0:
raise Exception("Emp sal must be multiple of 1000")
….
esal=[Link](validators=[multiples_of_1000])

Model Serializers
For normal serializers,
[Link] have to specify all fields explicitly
[Link] create(),update() explicitly
[Link]
class EmployeeSerializer([Link]):
class Meta:
model=Employee
fields=”__all__”
[Link]
….

Model serialization by default provides create(),update() methods

DRF VIEWS
DRF provides 2 classes to define business logic [Link] [Link]
class EmployeeCRUDCBV(APIView|ViewSet):
1. API view: Child class view ,get(),post() [Link] have write code explicitly and
the complete control is over [Link] execution flow,best suited for
operations like working with multiple data sources,other third party apis,map
urls and views explicitly
2. Viewset: list(),create(),retrieve(),update(),destroy(),partial_update().Most
of the code gets generated automatically.B est suited for simple operations
.urls are implemented by using router [Link] required to map [Link]
We use browsable api to check api functionality

Page No.43
REST API

[Link]
from [Link] import render
from rest_framework.views import APIViewfrom rest_framework.response
import Response
from [Link] import NameSerializer
class TestApiView(APIView):
def get(self,request,*args,**kwargs):
colors=['red','blue','black','green']
return Response({'msg':'Happy bday','colors':colors})
#Response converts dict to json data
def post(self,request,*args,**kwargs):
serializer=NameSerializer(data=[Link])
#data by browsable api interface
if serializer.is_valid():
name=[Link]('name')
msg="Hello {} happy bday -:".format(name)
return Response({'msg':msg})
else:
return Response([Link],status=404)
def put(self,request,*args,**kwargs):
return Response({'msg':'put method called'})
def patch(self,request,*args,**kwargs):
return Response({'msg':'patch method called'})
def delete(self,request,*args,**kwargs):
return Response({'msg':'delete method called'})
[Link]
from [Link] import admin
from [Link] import path
from [Link] import TestApiView
urlpatterns = [
path('admin/', [Link]),
path('api/',TestApiView.as_view())
]

Page No.44
REST API

[Link]
from rest_framework import serializers
class NameSerializer([Link]):
name=[Link](max_length=30)

perform make make migrations,migrate,run server and send request

Page No.45
REST API

Class 9: ViewSet
1. list() ➔To get all resources/records [get]
2. retrieve() ➔To get a particular resource [get]
3. create() ➔To create a new resource[post]
4. update() ➔To perform complete updation [put]
5. partial_update() ➔To perform partial updation [patch]
6. destroy() ➔To delete a resource [delete()]
When viewset is a best choice?
[Link] we want to develop a simple CRUD interface
[Link] develop API very quickly
[Link] perform standard operations
[Link] we are not performing any complex operations
Note: Routers will map views to urls automatically
[Link]
from [Link] import path,include
from [Link] import *
from rest_framework.routers import DefaultRouter
router=DefaultRouter()
[Link](‘endpointname’,TestViewSet,’endpointname’)
urlpatterns=[
….
path(‘api/ ‘,include([Link]))end user can send request upto this point
/api
[Link]
from [Link] import render
from rest_framework.response import Response
from [Link] import NameSerializer
from rest_framework.viewsets import ViewSet

Page No.46
REST API

class TestViewSet(ViewSet):
def list(self,request):
colors=['red','blue','black','green']
return Response({'msg':'Happy bday','colors':colors})
def create(self,request):
serializer=NameSerializer(data=[Link])
#data by browsable api interface
if serializer.is_valid():
name=[Link]('name')
msg="Hello {} happy bday -:".format(name)
return Response({'msg':msg})
else:
return Response([Link],status=404)
def retrieve(self,request,pk=None):
return Response({'msg':'Response through retrieve'})
def update(self,request,pk=None):
return Response({'msg':'Response through update'})
def partial_delete(self,request,pk=None):
return Response({'msg':'Response through partial delete'})
def destroy(self,request,pk=None):
return Response({'msg':'Response through destroy'})
[Link]
from [Link] import admin
from [Link] import path,include
from [Link] import TestViewSet
from rest_framework.routers import DefaultRouter
router=DefaultRouter()

Page No.47
REST API

[Link]('test_view_set',TestViewSet,"test_view_set")
urlpatterns = [
path('admin/', [Link]),
path('api/',include([Link]))
]
[Link]
from rest_framework import serializers
class NameSerializer([Link]):
name=[Link](max_length=30)INSTALLED_APPS = [
….
'myApp',
'rest_framework'
]
Runserver and send request
[Link]

Page No.48
REST API

Page No.49
REST API

Demo Application for APIView

[Link]
from [Link] import models
class Employee([Link]):
eno=[Link]()
ename=[Link](max_length=10)
esal=[Link]()
eaddr=[Link](max_length=100)
def __str__(self):
return [Link]
[Link]
from [Link] import admin
from [Link] import Employee
class EmployeeAdmin([Link]):
l=['eno','ename','esal','eaddr']
[Link](Employee,EmployeeAdmin)
myApp/[Link]
from rest_framework.serializers import ModelSerializer
from [Link] import Employee
class EmployeeSerializer(ModelSerializer):
class Meta:
model=Employee
fields="__all__"
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import EmployeeSerializer

Page No.50
REST API

from rest_framework.views import APIView

from rest_framework.response import Response
class EmployeeListApiView(APIView):
def get(self,request):
qs=[Link]()
serializer=EmployeeSerializer(qs,many=True)
return Response([Link])
[Link]
from [Link] import admin
from [Link] import path
from [Link] import EmployeeListApiView
urlpatterns = [
path('admin/', [Link]),
path('api/',EmployeeListApiView.as_view())
]
Perform make migrations,migrate,create super user and runserver
To list the records,we use ListAPIView available in rest_framework.generics
module
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import EmployeeSerializer
from rest_framework.generics import ListAPIView
from rest_framework.response import Response
class EmployeeListApiView(ListAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer

Page No.51
REST API

send request [Link]

To implement search options,
Send request along with the query string
[Link]
o/p➔all records
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import EmployeeSerializer
from rest_framework.generics import ListAPIView
from rest_framework.response import Response
class EmployeeListApiView(ListAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
def get_queryset(self):
qs=[Link]()
name=[Link]('ename')
if name is not None:
qs=[Link](ename__contains=name)
return qs
send request [Link]

Page No.52
REST API

Class 10: ViewSet CreateAPIView

For creating a record we use CreateAPIView
[Link]
from rest_framework.generics import ListAPIView,CreateAPIView
……
class EmployeeListApiView(ListAPIView):
………..
class EmployeeCreateApiView(CreateAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
[Link]
from [Link] import admin
from [Link] import path
from [Link] import *
urlpatterns = [
path('admin/', [Link]),
path('api1/',EmployeeListApiView.as_view()),
path('api2/',EmployeeCreateApiView.as_view())
]

Page No.53
REST API

Retrieve operation
To get a particular record we use RetrieveAPIView.
[Link]
from rest_framework.generics import
ListAPIView,CreateAPIView,RetrieveAPIView
class EmployeeListApiView(ListAPIView):
……
class EmployeeCreateApiView(CreateAPIView):
….

Page No.54
REST API

class EmployeeRetrieveApiView(RetrieveAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
[Link]
from [Link] import admin
from [Link] import url
from [Link] import *
urlpatterns = [
url('admin/', [Link]),
url('api1/',EmployeeListApiView.as_view()),
url('api2/',EmployeeCreateApiView.as_view()),
url('api3/(?P<pk>\d+)',EmployeeRetrieveApiView.as_view())
]

To replace,pk by id,give the line lookup_field='id' in views

class EmployeeRetrieveApiView(RetrieveAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
lookup_field='id'

Page No.55
REST API

Update operation UpdateAPIView

[Link]
from rest_framework.generics import UpdateAPIView
……
class EmployeeUpdateApiView(UpdateAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
lookup_field='id'
[Link]
from [Link] import admin
from [Link] import url
from [Link] import *
urlpatterns = [
url('admin/', [Link]),
url('api1/',EmployeeListApiView.as_view()),
url('api2/',EmployeeCreateApiView.as_view()),
url('api3/(?P<id>\d+)',EmployeeRetrieveApiView.as_view()),
url('api4/(?P<id>\d+)',EmployeeUpdateApiView.as_view())
]

DestroyAPIView
[Link]
from rest_framework.generics import DestroyAPIView
class EmployeeDeleteApiView(DestroyAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
lookup_field='id'

Page No.56
REST API

[Link]
from [Link] import admin
from [Link] import url
from [Link] import *
urlpatterns = [
…….,
url('api5/(?P<id>\d+)',EmployeeDeleteApiView.as_view())
]

Implement both List And Create Simultaneously

Use ListCreateAPIView
[Link]
from rest_framework.generics import ListCreateAPIView
class EmployeeListCreateApiView(ListCreateAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
[Link]
from [Link] import admin
from [Link] import url
from [Link] import *
urlpatterns = [
url('admin/', [Link]),
url('api/',EmployeeListCreateApiView.as_view()),
]

Page No.57
REST API

Implement both Retrieve and update operations

[Link]
from [Link] import render
from [Link] import Employee
from [Link] import EmployeeSerializer
from rest_framework.generics import RetrieveUpdateAPIView
class EmployeeRetrieveUpdateApiView(RetrieveUpdateAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
lookup_field='id'
[Link]
from [Link] import admin
from [Link] import url
from [Link] import EmployeeRetrieveUpdateApiView
urlpatterns = [
url('admin/', [Link]),
url('api/(?P<id>\d+)',EmployeeRetrieveUpdateApiView.as_view())
]

Implement Both Retrieve and Delete operations

[Link]
from [Link] import render
from [Link] import Employee
from [Link] import EmployeeSerializer
from rest_framework.generics import RetrieveDestroyAPIView
class EmployeeRetrieveDeleteApiView(RetrieveDestroyAPIView):
queryset=[Link]()

Page No.58
REST API

serializer_class=EmployeeSerializer
lookup_field='id'
[Link]
from [Link] import admin
from [Link] import url
from [Link] import EmployeeRetrieveDeleteApiView
urlpatterns = [
url('admin/', [Link]),
url('api/(?P<id>\d+)',EmployeeRetrieveDeleteApiView.as_view())
]

Perfrom Retrieve update delete operations simultaneously

[Link]
from [Link] import render
from [Link] import Employee
from [Link] import EmployeeSerializer
from rest_framework.generics import RetrieveUpdateDestroyAPIView
class
EmployeeRetrieveUpdateDeleteApiView(RetrieveUpdateDestroyAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
lookup_field='id'
[Link]
from [Link] import admin
from [Link] import url
from [Link] import EmployeeRetrieveUpdateDeleteApiView
urlpatterns = [

Page No.59
REST API

url('admin/', [Link]),
url('api/(?P<id>\d+)',EmployeeRetrieveUpdateDeleteApiView.as_view())
]

Implementing all CRUD operations using 2 endpoints

[Link]
[Link]
[Link]
from [Link] import render
from [Link] import Employee
from [Link] import EmployeeSerializer
from rest_framework.generics import
ListCreateAPIView,RetrieveUpdateDestroyAPIView
class EmployeeListCreateApiView(ListCreateAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer

class
EmployeeRetrieveUpdateDestroyApiView(RetrieveUpdateDestroyAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
lookup_field='id'
[Link]
from [Link] import admin
from [Link] import url
from [Link] import *
urlpatterns = [

Page No.60
REST API

url('admin/', [Link]),
url('api/$',EmployeeListCreateApiView.as_view()),

url('api/(?P<id>\d+)/$',EmployeeRetrieveUpdateDestroyApiView.as_view())
]
DRF VIEWS
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
MIXINS
[Link] classes meant for reausability
[Link] child classes of object
[Link] only the methods
rest_framework.mixins
ListModelMixin list(resquest,*args,**kwargs)
CreateModelMixin create(resquest,*args,**kwargs)
UpdateModelMixin update(resquest,*args,**kwargs)
partial_update (resquest,*args,**kwargs)
RetrieveModelMixin retrieve(resquest,*args,**kwargs)
DestroyModelMixin destroy(resquest,*args,**kwargs)

Page No.61
REST API

Ex1 :
[Link]
from rest_framework import mixins
from rest_framework.generics import ListAPIView
from [Link] import render
from [Link] import Employee
from [Link] import EmployeeSerializer
class EmployeeListModelMixin(ListAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer
[Link]
from [Link] import admin
from [Link] import url
from [Link] import EmployeeListModelMixin
urlpatterns = [
url('admin/', [Link]),
url('api/$',EmployeeListModelMixin.as_view())
]
[Link]
from rest_framework.mixins import *
from rest_framework.generics import *
from [Link] import render
from [Link] import Employee
from [Link] import EmployeeSerializer
class EmployeeListCreateModelMixin(CreateModelMixin,ListAPIView):
queryset=[Link]()
serializer_class=EmployeeSerializer

Page No.62
REST API

def post(self,request,*args,**kwargs):
return [Link](request,*args,**kwargs)
[Link]
from [Link] import admin
from [Link] import url
from [Link] import *
urlpatterns = [
url('admin/', [Link]),
url('api/$',EmployeeListCreateModelMixin.as_view())
]

Page No.63