django-rest-framework/docs/tutorial/4-authentication-and-permissions.md

# Tutorial 4: Authentication & Permissions

Currently our API doesn't have any restrictions on who can 


## Adding information to our model

We're going to make a couple of changes to our `Snippet` model class.
First, let's add a couple of fields.  One of those fields will be used to represent the user who created the code snippet.  The other field will be used to store the highlighted HTML representation of the code.

Add the following two fields to the model.

    owner = models.ForeignKey('auth.User', related_name='snippets')
    highlighted = models.TextField()

We'd also need to make sure that when the model is saved, that we populate the highlighted field, using the `pygments` code higlighting library.

We'll ned some extra imports:

    from pygments.lexers import get_lexer_by_name
    from pygments.formatters import HtmlFormatter
    from pygments import highlight

And now we can add a `.save()` method to our model class:

    def save(self, *args, **kwargs):
        """
        Use the `pygments` library to create an highlighted HTML
        representation of the code snippet.
        """
        lexer = get_lexer_by_name(self.language)
        linenos = self.linenos and 'table' or False
        options = self.title and {'title': self.title} or {}
        formatter = HtmlFormatter(style=self.style, linenos=linenos,
                                  full=True, **options)
        self.highlighted = highlight(self.code, lexer, formatter)
        super(Snippet, self).save(*args, **kwargs)

When that's all done we'll need to update our database tables.
Normally we'd create a database migration in order to do that, but for the purposes of this tutorial, let's just delete the database and start again.

    rm tmp.db
    python ./manage.py syncdb

You might also want to create a few different users, to use for testing the API.  The quickest way to do this will be with the `createsuperuser` command.

    python ./manage.py createsuperuser

## Adding endpoints for our User models

Now that we've got some users to work with, we'd better add representations of those users to our API.  Creating a new serializer is easy:

    class UserSerializer(serializers.ModelSerializer):
        snippets = serializers.ManyPrimaryKeyRelatedField()

        class Meta:
            model = User
            fields = ('pk', 'username', 'snippets')

Because `'snippets'` is a *reverse* relationship on the User model, it will not be included by default when using the `ModelSerializer` class, so we've needed to add an explicit field for it.

We'll also add a couple of views.  We'd like to just use read-only views for the user representations, so we'll use the `ListAPIView` and `RetrieveAPIView` generic class based views.

    class UserList(generics.ListAPIView):
        model = User
        serializer_class = UserSerializer
    
    
    class UserInstance(generics.RetrieveAPIView):
        model = User
        serializer_class = UserSerializer

Finally we need to add those views into the API, by referencing them from the URL conf.

    url(r'^users/$', views.UserList.as_view()),
    url(r'^users/(?P<pk>[0-9]+)/$', views.UserInstance.as_view())

## Associating Snippets with Users

Right now, if we created a code snippet, there'd be no way of associating the user that created the snippet, with the snippet instance.  The user isn't sent as part of the serialized representation, but is instead a property of the incoming request.

The way we deal with that is by overriding a `.pre_save()` method on our snippet views, that allows us to handle any information that is implicit in the incoming request or requested URL.

On **both** the `SnippetList` and `SnippetInstance` view classes, add the following method:

    def pre_save(self, obj):
        obj.owner = self.request.user

## Updating our serializer

Now that snippets are associated with the user that created them, let's update our SnippetSerializer to reflect that.

Add the following field to the serializer definition:

    owner = serializers.Field(source='owner.username')

**Note**: Make sure you also add `'owner',` to the list of fields in the inner `Meta` class.

This field is doing something quite interesting.  The `source` argument controls which attribtue is used to populate a field, and can point at any attribute on the serialized instance.  It can also take the dotted notation shown above, in which case it will traverse the given attributes, in a similar way as is used with Django's template language.

The field we've added is the untyped `Field` class, in contrast to the other typed fields, such as `CharField`, `BooleanField` etc...  The untyped `Field` is always read-only, and will be used for serialized representations, but will not be used for updating model instances when they are deserialized.

**TODO: Explain the SessionAuthentication and BasicAuthentication classes, and demonstrate using HTTP basic authentication with curl requests**

## Adding required permissions to views

Now that code snippets are associated with users we want to make sure that only authenticated users are able to create, update and delete code snippets.

REST framework includes a number of permission classes that we can use to restrict who can access a given view.  In this case the one we're looking for is `IsAuthenticatedOrReadOnly`, which will ensure that authenticated requests get read-write access, and unauthenticated requests get read-only access.

Add the following property to **both** the `SnippetList` and `SnippetInstance` view classes.

    permission_classes = (permissions.IsAuthenticatedOrReadOnly,)

**TODO: Now that the permissions are restricted, demonstrate using HTTP basic authentication with curl requests**

## Adding login to the Browseable API

If you open a browser and navigate to the browseable API at the moment, you'll find you're no longer able to create new code snippets.  In order to do so we'd need to be able to login as a user.

We can add a login view for use with the browseable API, by editing our URLconf once more.

Add the following import at the top of the file:

    from django.conf.urls import include

And, at the end of the file, add a pattern to include the login and logout views for the browseable API.

    urlpatterns += patterns('',
        url(r'^api-auth/', include('rest_framework.urls',
                                   namespace='rest_framework'))
    )

The `r'^api-auth/'` part of pattern can actually be whatever URL you want to use.  The only restriction is that the included urls must use the `'rest_framework'` namespace.

Now if you open up the browser again and refresh the page you'll see a 'Login' link in the top right of the page.  If you log in as one of the users you created earier, you'll be able to create code snippets again.

Once you've created a few code snippets, navigate to the '/users/' endpoint, and notice that the representation includes a list of the snippet pks that are associated with each user, in each user's 'snippets' field.

## Object level permissions

Really we'd like all code snippets to be visible to anyone, but also make sure that only the user that created a code snippet is able update or delete it.

To do that we're going to need to create a custom permission.

In the snippets app, create a new file, `permissions.py`

    from rest_framework import permissions
    
    
    class IsOwnerOrReadOnly(permissions.BasePermission):
        """
        Custom permission to only allow owners of an object to edit it.
        """

        def has_permission(self, request, view, obj=None):
            # Skip the check unless this is an object-level test
            if obj is None:
                return True
    
            # Read permissions are allowed to any request
            if request.method in permissions.SAFE_METHODS:            
                return True
    
            # Write permissions are only allowed to the owner of the snippet
            return obj.owner == request.user

Now we can add that custom permission to our snippet instance endpoint, by editing the `permission_classes` property on the `SnippetInstance` class:

    permission_classes = (permissions.IsAuthenticatedOrReadOnly,
                          IsOwnerOrReadOnly,)

Make sure to also import the `IsOwnerOrReadOnly` class.

    from snippets.permissions import IsOwnerOrReadOnly

Now, if you open a browser again, you find that the 'DELETE' and 'PUT' actions only appear on a snippet instance endpoint if you're logged in as the same user that created the code snippet.

## Summary

We've now got a fairly fine-grained set of permissions on our Web API, and end points for users of the system and for the code snippets that they have created.

In [part 5][tut-5] of the tutorial we'll look at how we can tie everything together by creating an HTML endpoint for our hightlighted snippets, and improve the cohesion of our API by using hyperlinking for the relationships within the system.

[tut-5]: 5-relationships-and-hyperlinked-apis.md