Django snippets: Resource

import string

from django.http import HttpResponse, HttpResponseNotAllowed


class Resource(HttpResponse):
    
    """Represents a single resource within a RESTful web service.
    
    The ``Resource`` class should be used to represent a single resource
    within a RESTful web service. It exists to be subclassed for each
    resource within the service, and these subclasses should define a method
    for each possible HTTP request method on the so"""
	
	def __init__(self, request, *args, **kwargs):
	    """Instantiate a ``Resource`` instance.
	    
	    This method overrides ``HttpResponse.__init__``, providing an
	    alternative way of serving views. It calls the overridden method
	    first, to handle the initialization, and then performs a dispatch
	    on the HTTP request method. The return values of these methods are
	    then merged back into the current ``HttpResponse`` instance.
	    
	    Because this is called like a view function, this method accepts
	    a request object and any other positional and/or keyword arguments,
	    These will be passed to the methods defined on a subclass, so those
	    methods should support any arguments given.
	    
	    If the given HTTP request method is not defined for a subclass, then
	    a 405 'Method Not Allowed' response is returned, along with a list
	    of allowed methods (obtained via introspection)."""
		HttpResponse.__init__(self)
		if hasattr(self, request.method.lower()):
			value = getattr(self, request.method.lower())(request,
			    *args, **kwargs)
			if isinstance(value, HttpResponse):
				self._update(value)
		elif hasattr(self, 'run'):
			value = self.run(request, *args, **kwargs)
			if isinstance(value, HttpResponse):
				self._update(value)
		else:
		    allowed_methods = []
		    for attr in dir(self):
		        if set(attr).issubset(set(string.lowercase)):
		            allowed_methods.append(attr.upper())
		    self._update(HttpResponseNotAllowed(sorted(allowed_methods)))
	
	def _update(self, response):
	    """Merge the info from another response with this instance.
	    
	    This method simply copies the attributes from the given response to
	    this instance, with the exceptions of the ``_headers`` and ``cookies``
	    dictionaries, whose ``update`` methods are called. This means that any
	    headers or cookies which are present in this response but not the
	    argument are preserved."""
		self._charset = response._charset
		self._is_string = response._is_string
		self._container = response._container
		self._headers.update(response._headers)
		self.cookies.update(response.cookies)
		self.status_code = response.status_code

More like this

Base class for RESTful Views by jpwatts 4 years, 5 months ago
EasyFeed class by limodou 6 years, 2 months ago
Ajax API class by kcarnold 4 years, 11 months ago
URL models by diverman 3 years, 7 months ago
Using class methods as views by panyam 3 years, 11 months ago

The Resource class is a way of writing a Django view as a class. I've done this as part of an effort to write easier-to-understand RESTful apps, as this allows the grouping of similar views as different types of operation on a resource. Essentially, the solution goes something like this:

Views have to be callables which return HttpResponse objects.
The problem with views as classes is that calling a view class returns an instance of the view class, not HttpResponse.
Solution: have the VC (view class) a subclass of HttpResponse. This way, 'calling' the class will return a HttpResponse instance.

The Resource class performs a dispatch on the request method, so that a resource can be retrieved, created/updated and deleted by writing 'get', 'put' and 'delete' methods on a subclass of Resource.

A general Book class shows how this might work for the case of 'books' in a system:

class Book(Resource):
    def get(self, request, book_name):
        book = myapp.models.Book.objects.get(name=book_name)
        return render_to_response('book_template.html', {'book': book})

    def put(self, request, book_name):
        new_book, created = get_or_create(myapp.models.Book, name=book_name)
        new_book.data = request.raw_post_data
        if created:
            return HttpResponse(status=201)
        return HttpResponse(status=200)

    def delete(self, request, book_name):
        book = myapp.models.Book.objects.get(name=book_name)
        book.delete()
        return HttpResponse()

As you can see, classes can return responses, and these will be merged back into the returned response by the Resource._update method.

Author:: zvoase
Posted:: September 21, 2008
Language:: Python
Django Version:: 1.0
Tags:: rest resource view-class view-as-a-class
Score:: 3 (after 3 ratings)

Tools

Comments

simon (on September 21, 2008):

Interesting approach. My solution to "the problem with views as classes is that calling a view class returns an instance of the view class, not HttpResponse" is to add a call(self, request) method to the class, then use an instance of that class in the URLconf rather than the class itself - see http://www.djangosnippets.org/snippets/1071/ for an example

bryhoyt (on March 6, 2010):

Shouldn't you be checking that attr is in a list of allowed HTTP methods (GET/POST/PUT etc)? Otherwise the client-side could execute arbitrary methods of any subclass of Resource.

Django snippets

Resource

More like this

Tools

Comments

Snippets

About