from django.template import RequestContext, loader

from django.http import Http404, HttpResponse, HttpResponseRedirect

from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured

from django.utils.translation import ugettext

from django import newforms as forms

from django.newforms.models import ModelFormMetaclass, ModelForm

class BaseView(object):

    """

    Base class for generic object creation and update view.

    Templates: ``<app_label>/<model_name>_form.html``

    Context:

        form

            the ``ModelForm`` instance for the object

    """

    def __init__(self, model, post_save_redirect=None):

        self.model = model

        self.post_save_redirect = None

    def __call__(self, request):

        return self.main(request, self.get_instance(request))

    def main(self, request, instance):

        Form = self.get_form(request)

        if request.POST:

            form = Form(request.POST, request.FILES, instance=instance)

            if form.is_valid():

                new_object = self.save(request, form)

                return self.on_success(request, new_object)

        else:

            form = Form()

        rendered_template = self.get_rendered_template(request, instance, form)

        return HttpResponse(rendered_template)

    def get_form(self, request):

        """

        Returns a ``ModelForm`` class to be used in this view.

        """

        # TODO: we should be able to construct a ModelForm without creating

        # and passing in a temporary inner class

        class Meta:

            model = self.model

        class_name = self.model.__name__ + 'Form'

        return ModelFormMetaclass(class_name, (ModelForm,), {'Meta': Meta})

    def get_context(self, request, instance, form=None):

        """

        Returns a ``Context`` instance to be used when rendering this view.

        """

        return RequestContext(request, {'form': form, 'object': instance})

    def get_template(self, request):

        """

        Returns the template to be used when rendering this view. Those who

        wish to use a custom template loader should do so here.

        """

        opts = self.model._meta

        template_name = "%s/%s_form.html" % (opts.app_label, opts.object_name.lower())

        return loader.get_template(template_name)

    def get_rendered_template(self, request, instance, form=None):

        """

        Returns a rendered template. This will be passed as the sole argument

        to HttpResponse()

        """

        template = self.get_template(request)

        context = self.get_context(request, instance, form)

        return template.render(context)

    def save(self, request, form):

        """

        Saves the object represented by the given ``form``. This method will

        only be called if the form is valid, and should in most cases return

        an HttpResponseRediect. It's return value will be the return value

        for the view on success.

        """

        return form.save()

    def on_success(self, request, new_object):

        """

        Returns an HttpResonse, generally an HttpResponse redirect. This will

        be the final return value of the view and will only be called if the

        object was saved successfuly.

        """

        if request.user.is_authenticated():

            message = self.get_message(request, new_object)

            request.user.message_set.create(message=message)

        # Redirect to the new object: first by trying post_save_redirect,

        # then by obj.get_absolute_url; fail if neither works.

        if self.post_save_redirect:

            return HttpResponseRedirect(post_save_redirect % new_object.__dict__)

        elif hasattr(new_object, 'get_absolute_url'):

            return HttpResponseRedirect(new_object.get_absolute_url())

        else:

            raise ImproperlyConfigured("No URL to redirect to from generic create view.")

        suite = unittest.TestLoader().loadTestsFromTestCase(self.__class__)

        unittest.TextTestRunner(verbosity=1).run(suite)

    def test_model(self):

        from test_models import Article

        a = Article.objects.create(headline="ahl")

        self.assertEqual(a.headline,"ahl")

    extra_tests = [ClassViewTests(), ]

from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured

from django.http import Http404, HttpResponse, HttpResponseNotAllowed

from django.template import loader

#from django.views.generic.base import BaseDetailView

from base import BaseView

class HtmlResponder(object):

    """

    HtmlResponder renders an object or a list of objects with the Django

    templating system.

    """

    name = "html"

    def __init__(self, queryset):

        self.queryset = queryset

    def render_response(self, request, template, context_vars, mimetype=None):

        """

        Returns an HttpResponse for the given requesxt, template object,

        dictionary of context variables, and optional mimetype.

        """

        context = RequestContext(request, context_vars)

        template = template.render(context)

        return HttpResponse(template, mimetype=mimetype)

    def get_template(self, opts, target='list'):

        """

        Returns a loaded template, the template_name depends of the model name.

        Examples::

            blog/post_list.html

            auth/user_detail.html

        """

        template_name = "%s/%s_%s.html" % (opts.app_label, opts.object_name.lower(), target) 

        return loader.get_template(template_name)

    def get_context_vars(self, context_vars):

        """

        Returns a dictionary of context vars, override if you need more.

        """

        return context_vars

    def list(self, request, paginate_by, allow_empty):

        """

        Renders a list of model objects to HttpResponse.

        """

        if paginate_by:

            paginator = QuerySetPaginator(self.queryset, paginate_by,

                                          allow_empty_first_page=allow_empty)

            page = request.GET.get('page', 1)

            try:

                page_number = int(page)

            except ValueError:

                if page == 'last':

                    page_number = paginator.num_pages

                else:

                    # Page is not 'last', nor can it be converted to an int.

                    raise Http404

            try:

                page_obj = paginator.page(page_number)

            except InvalidPage:

                raise Http404

            object_list = page_obj.object_list

        else:

            object_list = self.queryset

            paginator = None

            page_obj = None

            if not allow_empty and len(self.queryset) == 0:

                raise Http404

        context_vars = self.get_context_vars({

            'object_list': object_list,

            'paginator': paginator,

            'page_obj': page_obj

        })

        opts = self.queryset.model._meta

        template = self.get_template(opts)

        return self.render_response(request, template, context_vars)

    def element(self, request, obj):

        """

        Renders single model objects to HttpResponse.

        """

        context_vars = self.get_context_vars({'object': obj})

        opts = self.queryset.model._meta

        template = self.get_template(opts, target='detail')

        response = self.render_response(request, template, context_vars)

        populate_xheaders(request, response, self.queryset.model, getattr(obj, opts.pk.name))

        return response

    def create_success(self, request, new_obj, post_save_redirect):

        """

        Returns an HttpResonse, generally an HttpResponse redirect. This will

        be the final return value of the view and will only be called if the

        object was saved successfuly.

        """

        # Redirect to the new object: first by trying post_save_redirect,

        # then by obj.get_absolute_url; fail if neither works.

        if post_save_redirect:

            return HttpResponseRedirect(post_save_redirect % new_obj.__dict__)

        elif hasattr(new_obj, 'get_absolute_url'):

            return HttpResponseRedirect(new_obj.get_absolute_url())

        else:

            raise ImproperlyConfigured("No URL to redirect to from generic create view.")

    def update_success(self, request, obj, new_obj, post_save_redirect):

        """

        Returns an HttpResonse, generally an HttpResponse redirect. This will

        be the final return value of the view and will only be called if the

        object was saved successfuly.

        """

        # Redirect to the new object: first by trying post_save_redirect,

        # then by obj.get_absolute_url; fail if neither works.

        if post_save_redirect:

            return HttpResponseRedirect(post_save_redirect % new_obj.__dict__)

        elif hasattr(new_obj, 'get_absolute_url'):

            return HttpResponseRedirect(new_obj.get_absolute_url())

        else:

            raise ImproperlyConfigured("No URL to redirect to from generic create view.")

    def delete_success(self, post_save_redirect):

        return HttpResponseRedirect(post_save_redirect)

class JsonResponder(object):

    """TODO"""

class ModelView(BaseView):

    """

    ModelView: a RESTful class-based view of your resources

    =======================================================

    Philosophy

    ----------

    The goal of this class is to provide a lightweight REST interface, I know

    that django-rest-interface exists but it's abandoned and it suffers from

    some defaults. Given my experience with it, I always need to rewrite large

    parts of the library in order to customize it to fits with my own needs.

    In order to avoid this with ModelView, the philosophy is to allow 

    dead-easy subclassing with granularity at each point.

    Note: I totally respect what had been done before and this class is 

    inspired from a lot of existing projects so many thanks to all authors.

    Goals

    -----

    Basically, it dispatches requests to the appropriated function given the

    HTTP verb and it allows you to specify a responder in order to avoid 

    duplication of code at the resource logic level.

    You can specify your own responders, and restrict to allowed HTTP methods.

    Secret goal: to be honest, I dream of resource oriented stuff in 

    Django's trunk for years now. A RESTful Django's (newforms-)admin could be

    awesome too in order to provide a built-in API!

    Example

    -------

    A quick example in order to demonstrate what is possible.

    models.py::

        class Post(models.Model):

            title = models.Charfield(max_length=200)

            slug = models.SlugField(max_length=200, prepopulate_from=('title',), unique=True)

            content = models.TextField()

    urls.py::

        blog = ModelView(Post.objects.filter(is_online=True), responders=(HtmlResponder, JsonResponder), methods=('GET',))

        blog_admin = ModelView(Post.objects.all(), methods=('GET', 'POST', 'PUT', 'DELETE'))

        urlpatterns = pattern('', 

            url(^blog/(?P<slug>[-\w]+)/(?P<format>(html|json))?/?$), blog, name='blog'),

            url(^blog/admin/(?P<object_pk>\d)/), blog_admin, name='blog_admin'),

        )

    Note: here we consider that you want a custom admin for your blog,

    otherwise Django's built-in admin is much more interesting, of course.

    TODO

    ----

        * Add tests and documentation

        * Create a collection of generic Responders

        * Handle receivers in order to use it as an API (for the moment,

          it assumes that you receive formencoded data), need more reflexion.

        * Handle privacy, need more reflexion

        * See what can be done with APP, it could be fun!

        * Ideas?

    """

    def __init__(self, queryset, slug_field='slug', post_save_redirect=None,

                 paginate_by=None, allow_empty=True,

                 responders=(HtmlResponder,),

                 methods=('GET', 'POST', 'PUT', 'DELETE')):

        self.queryset = queryset

        self.post_save_redirect = post_save_redirect

        self.paginate_by = paginate_by

        self.allow_empty = allow_empty

        self.responders = dict((responder.name, responder) for responder in responders)

        self.methods = methods

        super(ModelView, self).__init__(queryset, slug_field)

    def __call__(self, request, object_pk=None, slug=None, format='html'):

        """

        Redirects to one of the CRUD methods depending on the HTTP method of 

        the request. Checks whether the requested method is allowed for this 

        resource.

        """

        # If we didn't get object_pk or slug, assume this is an add view.

        if object_pk is None and slug is None:

            obj = None

        else:

            obj = self.get_object(request, object_pk, slug)

        # Restrict

        request_method = request.method.upper()

        if request_method not in self.methods:

            raise HttpMethodNotAllowed

        # Dispatch

        if request_method == 'GET':

            return self.read(request, obj, self.get_responder(format))

        elif request_method == 'POST':

            return self.create(request, self.get_responder(format))

        elif request_method == 'PUT':

            return self.update(request, obj, self.get_responder(format))

        elif request_method == 'DELETE':

            return self.delete(request, obj, self.get_responder(format))

        else:

            raise Http404

    def get_object(self, request, object_pk, slug):

        if object_pk:

            return self.queryset.get(pk=object_pk)

        elif slug:

            return self.queryset.get(slug=slug)

        return None

    def get_query_set(self):

        return self.queryset

    def get_responder(self, format):

        """

        Returns a ``Responder`` instance given the format.

        """

        try:

            return self.responders[format](self.get_query_set())

        except KeyError:

            raise ImproperlyConfigured("%s responder doesn't exist." % '%sResponder' % format.title())

    def get_form(self, request):

        """

        Returns a ``ModelForm`` class to be used in this view.

        """

        # TODO: we should be able to construct a ModelForm without creating

        # and passing in a temporary inner class

        class Meta:

            model = self.model

        class_name = self.model.__name__ + 'Form'

        return ModelFormMetaclass(class_name, (ModelForm,), {'Meta': Meta})

    def save_form(self, request, form):

        """

        Saves and returns the object represented by the given form. This

        method will only be called if the form is valid.

        """

        return form.save()

    def read(self, request, obj, responder):

        """

        Returns a rendered list or element whether ``obj`` exists, idempotent.

        """

        if obj is None:

            return responder.list(request, self.paginate_by, self.allow_empty)

        else:

            return responder.element(request, obj)

    def create(self, request, responder):

        """

        Create a new resource.

        """

        Form = self.get_form(request)

        form = Form(request.POST, request.FILES)

        if form.is_valid():

            new_obj = self.save_form(request, form)

            return responder.create_success(request, new_obj, self.post_save_redirect)

    def update(self, request, obj, responder):

        """

        Update an existing resource (there is no PUT creation for now), idempotent.

        """

        Form = self.get_form(request)

        form = Form(request.POST, request.FILES, instance=obj)

        if form.is_valid():

            new_obj = self.save_form(request, form)

            return responder.update_success(request, obj, new_obj, self.post_save_redirect)

    def delete(self, request, obj, responder):

        """

        Delete an existing resource, idempotent.

        """

        if obj is not None:

            obj.delete()

        return responder.delete_success(self.post_save_redirect)

#!/usr/bin/env python

from django.core.management import execute_manager

try:

    import settings # Assumed to be in the same directory.

except ImportError:

    import sys

    sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)

    sys.exit(1)

if __name__ == "__main__":

    execute_manager(settings)

import os, os.path

DEBUG = True

TEMPLATE_DEBUG = DEBUG

ADMINS = ()

MANAGERS = ADMINS

DATABASE_ENGINE = 'sqlite3'

DATABASE_NAME = u"%s/%s" % (os.getcwd(), "testdb.sqlite")

TIME_ZONE = 'America/Chicago'

LANGUAGE_CODE = 'en-us'

SITE_ID = 1

USE_I18N = True

MEDIA_ROOT = ''

MEDIA_URL = ''

ADMIN_MEDIA_PREFIX = '/media/'

SECRET_KEY = 'yi@)jk!m$r)^v_9)n8_ouzaey$!zqorqh&2)zfyq^=&_qe-x%^'

TEMPLATE_DIRS = (

    os.path.join(os.path.abspath(os.getcwd()), 'templates'),

)

print TEMPLATE_DIRS

MIDDLEWARE_CLASSES = ()

ROOT_URLCONF = 'test_project.urls'

TEMPLATE_DIRS = ()

INSTALLED_APPS = (

    'django_modelview',

    'django_modelview.test_project.test_app',

)

<h3> {{ object.title }} </h3>

<p> {{ object.content }} </p>

{% for object in object_list %}

<h3> {{ object.title }} </h3>

{% endfor %}

from django.db import models

class Post(models.Model):

    title = models.CharField(max_length=200)

    slug = models.SlugField(max_length=200, prepopulate_from=('title',), unique=True)

    content = models.TextField()

    def __unicode__(self):

        return self.title

import unittest

from django.test.client import Client

from models import Post

class modelTest(unittest.TestCase):

    def setUp(self):

        self.client = Client()

        Post.objects.create(title="abc",

                            slug="aabbcc",

                            content="A post.")

    def tearDown(self):

        for obj in Post.objects.all():

            obj.delete()

    def test_models(self):

        p = Post.objects.create(title="A simple post",

                                   slug="a-simple-post",

                                   content="A post.")

        self.assertEqual(p.title, "A simple post")

    def test_model_view(self):

        response = self.client.get('/blog/aabbcc/html/')

# Create your views here.

from django.conf.urls.defaults import *

from django_modelview.rest_views import *

from test_app.models import Post

blog = ModelView(

    Post.objects.all(),

    responders=(HtmlResponder,), 

    methods=('GET',)

    )

urlpatterns = patterns(

    '', 

    (r'^blog/(?P<slug>[-\w]+)/(?P<format>(html|json))?/?$', blog),

    )