Question

I’ve been experimenting with Django’s Class Based Views and am trying to write a simple class based view that processes certain information in request so that the processed information can be used by the “handler” method.

I don’t seem to have fully understood what the docs say and am unsure of whether this should be a Mixin, a generic view or something else. I’m thinking of making a class like this:

class MyNewGenericView(View):

    redirect_on_error = 'home'
    error_message = 'There was an error doing XYZ'

    def dispatch(self, request, *args, **kwargs):
        try:
            self.process_information(request)
            # self.process_information2(request)
            # self.process_information3(request)
            # etc...
        except ValueError:
            messages.error(request, self.error_message)
            return redirect(self.redirect_on_error)
        return super(MyNewGenericView, self).dispatch(request, *args, **kwargs)

    def process_information(self, request):
        # Use get/post information and process it using
        # different models, APIs, etc.
        self.useful_information1 = 'abc'
        self.useful_information2 = 'xyz'

    def get_extra_info(self):
        # Get some extra information on something
        return {'foo':'bar'}

This will allow someone to write a view like:

class MyViewDoesRealWork(MyNewGenericView):
    def get(self, request, some_info):
        return render(request, 'some_template.html',
            {'info':self.useful_information1})

    def post(self, request, some_info):
        # Store some information, maybe using get_extra_info
        return render(request, 'some_template.html',
            {'info':self.useful_information1})

Is the above code the right way to go? Is there any simpler/better way of doing this? Will this prevent the above functionalities from being used in another generic view (e.g. a built-in generic view)?

Answer 1

It seems I just asked a stupid question.

This can easily be achieved by making a class that processes that information:

class ProcessFooInformation(object):
    def __init__(self, request):
        self.request = request
    @property
    def bar(self):
        baz = self.request.GET.get('baz', '')
        # do something cool to baz and store it in foobar
        return foobar
    # etc...

Then using old style function views or new class-based views:

def my_view(request):
    foo = ProcessFooInformation(request)
    # use foo in whatever way and return a response
    return render(request, 'foobar.html', {'foo':foo})

I also made this more efficient by using lazy evaluation of properties.

I adapted ideas from the lazy property evaluation recipe and the comments to write a wrapper:

def lazy_prop(func):
    def wrap(self, *args, **kwargs):
        if not func.__name__ in self.__dict__:
            self.__dict__[func.__name__] = func(self, *args, **kwargs)
        return self.__dict__[func.__name__]
    return property(wrap)

This evaluates the value of the wrapped method only once per instance and uses a stored value on subsequent calls. This is useful if the property evaluates slowly.