Introducción a Django Rest Framework

• SOAP
• Tastypie
• Adhoc
• Django Rest Framework

• Aplicación Django
• Generador de APIs REST
• Open Source
• Creado por Tom Christie a finales del 2010
• Compatible con python2 y python3
• Compatible con Django >= 1.3

• API navegable
• Facil de implementar APIs simples
• Facil de implementar APIs RESTful
• Facil de probar
• Facil de extender o personalizar
• Muy modular (basado principalmente en Mixins)
• Muy bien documentado
• Amplia comunidad de usuarios

Solo son necesarios 3 pasos:

• Definir mi modelo
• Definir un viewset (Recurso)
• Definir y usar un router

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    thing = models.IntegerField()
    internal_thing = models.FloatField(null=True, blank=True)
    owner = models.ForeignKey(User)
                            

class MyModelViewSet(viewsets.ModelViewSet):
    model = MyModel
                            

router = DefaultRouter()
router.register('my-model', MyModelViewSet)

urlpatterns = patterns('',
    url(r'^api/v1/', include(router.urls)),
    ...
)
                            

• APIViews
• ViewSet
• Routers
• Parsers
• Renderers
• Serializers
• Autentications
• Permissions
• Filters

• Class Views.
• Extiende el HTTPRequest.
• Extiende el HTTPResponse.
• Captura las excepciones APIException.
• Procesa la autenticación, permisos y demas de las peticiones.

• APIViews.
• Permite definir todas las acciones de un recurso en una sola vista.
• Utiliza el Router para definir sus urls.
• Permite definir acciones extra en la API de manera sencilla.

• Permite definir las urls de uno o varios ViewSets.

• Define como convertir los datos enviados por el usuario a tipos basicos de python.

• Define como convertir los tipos basicos de python a datos para el usuario.

• Define como convertir datos internos de la aplicacion a los tipos basicos de python (y viceversa).

• Define como saber si una petición esta autenticada.

• Define como saber si una petición esta autorizada.

• Filtra los contenidos de un ModelViewSet o un ModelAPIView.

class MyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = ('id', 'name', 'thing', 'owner')

class MyModelViewSet(viewsets.ModelViewSet):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer
                            

O puedes definirlo globalmente en DEFAULT_MODEL_SERIALIZER_CLASS.

class MyModelViewSet(viewsets.ModelViewSet):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer
    authentication_classes = (SessionAuthentication, BasicAuthentication)
    permission_classes = (IsAuthenticated,)
                            

O puedes definirlos globalmente en DEFAULT_PERMISSION_CLASSES y DEFAULT_AUTHENTICATION_CLASSES.

class MyModelViewSet(viewsets.ModelViewSet):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer
    authentication_classes = (SessionAuthentication, BasicAuthentication)
    permission_classes = (IsAuthenticated,)
    paginate_by = 10
    paginate_by_param = 'page_size'
    max_paginate_by = 100
                            

O puedes definirlo globalmente en PAGINATE_BY, PAGINATE_BY_PARAM y MAX_PAGINATE_BY.

class IsOwnerFilterBackend(filters.BaseFilterBackend):
    def filter_queryset(self, request, queryset, view):
        return queryset.filter(owner=request.user)

class MyModelViewSet(viewsets.ModelViewSet):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer
    authentication_classes = (SessionAuthentication, BasicAuthentication)
    permission_classes = (IsAuthenticated,)
    filter_backends = (IsOwnerFilterBackend, filters.OrderingFilter,)
    paginate_by = 10
    paginate_by_param = 'page_size'
    max_paginate_by = 100
                            

O puedes definirlo globalmente en DEFAULT_FILTER_BACKENDS.

class NoModelViewSet(viewsets.ViewSet):
    authentication_classes = (SessionAuthentication, BasicAuthentication)
    permission_classes = (IsAuthenticated,)
    def list(self, request):
        return Response([{'hello': 'list'}])
    def retrieve(self, request, pk=None):
        return Response({'hello': pk})
    def create(self, request):
        return Response({'hello': 'create', 'data': request.DATA})
    def update(self, request, pk=None):
        return Response({'hello': pk, 'data': request.DATA})
    def partial_update(self, request, pk=None):
        return Response({'hello': pk, 'data': request.DATA})
    def destroy(self, request, pk=None):
        return Response({'hello': pk})
                            

class NoModelAPIView(views.APIView):
    authentication_classes = (SessionAuthentication, BasicAuthentication)
    permission_classes = (IsAuthenticated,)

    def get(self, request, format=None):
        return Response([{'hello': 'get'}])

    def post(self, request, format=None):
        return Response([{'hello': 'post'}])

    def put(self, request, format=None):
        return Response([{'hello': 'put'}])

    def delete(self, request, format=None):
        return Response([{'hello': 'delete'}])
                            

class MyModelSerializer(serializers.ModelSerializer):
    method_field = serializers.SerializerMethodField('get_method_field_data')
    private_data = serializers.Field(source='internal_thing')

    def get_method_field_data(self, obj):
        return "This is a method generated data!"

    class Meta:
        model = MyModel
        fields = ('id', 'name', 'thing', 'owner', 'private_data', 'method_field')