Synnefo

#

# Copyright 2011 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from django import http

from django.utils import simplejson as json

from django.core.urlresolvers import reverse

from django.http import HttpResponse

from django.core.exceptions import ValidationError, NON_FIELD_ERRORS

from snf_django.lib.astakos import get_user

from django.conf import settings

class View(object):

    """

    Intentionally simple parent class for all views. Only implements

    dispatch-by-method and simple sanity checking.

    """

    method_names = ['GET', 'POST', 'DELETE', 'HEAD', 'OPTIONS', 'TRACE']

    def __init__(self, *args, **kwargs):

        """

        Constructor. Called in the URLconf; can contain helpful extra

        keyword arguments, and other things.

        """

        # Go through keyword arguments, and either save their values to our

        # instance, or raise an error.

        for key, value in kwargs.items():

            if key in self.method_names:

                raise TypeError(u"You tried to pass in the %s method name as a"

                                u" keyword argument to %s(). Don't do that."

                                % (key, self.__class__.__name__))

            if hasattr(self, key):

                setattr(self, key, value)

            else:

                raise TypeError(u"%s() received an invalid keyword %r" % (

                    self.__class__.__name__,

                    key,

                ))

    @classmethod

    def as_view(cls, *initargs, **initkwargs):

        """

        Main entry point for a request-response process.

        """

        def view(request, *args, **kwargs):

            get_user(request, settings.ASTAKOS_BASE_URL)

            if not request.user_uniq:

                return HttpResponse(status=401)

            self = cls(*initargs, **initkwargs)

            return self.dispatch(request, *args, **kwargs)

        return view

    def dispatch(self, request, *args, **kwargs):

        # Try to dispatch to the right method for that; if it doesn't exist,

        # raise a big error.

        if hasattr(self, request.method.upper()):

            self.request = request

            self.args = args

            self.kwargs = kwargs

            data = request.body

            if request.method.upper() in ['POST', 'PUT']:

                # Expect json data

                if request.META.get('CONTENT_TYPE').startswith(

                        'application/json'):

                    try:

                        data = json.loads(data)

                    except ValueError:

                        return \

                            http.HttpResponseServerError('Invalid JSON data.')

                else:

                    return http.HttpResponseServerError(

                        'Unsupported Content-Type.')

            try:

                return getattr(self, request.method.upper())(

                    request, data, *args, **kwargs)

            except ValidationError, e:

                # specific response for validation errors

                return http.HttpResponseServerError(

                    json.dumps({'errors': e.message_dict,

                                'non_field_key': NON_FIELD_ERRORS}))

        else:

            allowed_methods = [m for m in self.method_names if hasattr(self, m)]

            return http.HttpResponseNotAllowed(allowed_methods)

class JSONRestView(View):

    """

    Class that provides helpers to produce a json response

    """

    url_name = None

    def __init__(self, url_name, *args, **kwargs):

        self.url_name = url_name

        return super(JSONRestView, self).__init__(*args, **kwargs)

    def update_instance(self, i, data, exclude_fields=[]):

        update_keys = data.keys()

        for field in i._meta.get_all_field_names():

            if field in update_keys and (field not in exclude_fields):

                i.__setattr__(field, data[field])

        return i

    def instance_to_dict(self, i, exclude_fields=[]):

        """

        Convert model instance to python dict

        """

        d = {}

        d['uri'] = reverse(self.url_name, kwargs={'id': i.pk})

        for field in i._meta.get_all_field_names():

            if field in exclude_fields:

                continue

            d[field] = i.__getattribute__(field)

        return d

    def qs_to_dict_iter(self, qs, exclude_fields=[]):

        """

        Convert queryset to an iterator of model instances dicts

        """

        for i in qs:

            yield self.instance_to_dict(i, exclude_fields)

    def json_response(self, data):

        return http.HttpResponse(json.dumps(data), mimetype="application/json")

class ResourceView(JSONRestView):

    method_names = ['GET', 'POST', 'PUT', 'DELETE']

    model = None

    exclude_fields = []

    def queryset(self):

        return self.model.objects.all()

    def instance(self):

        """

        Retrieve selected instance based on url parameter

        id parameter should be set in urlpatterns expression

        """

        try:

            return self.queryset().get(pk=self.kwargs.get("id"))

        except self.model.DoesNotExist:

            raise http.Http404

    def GET(self, request, data, *args, **kwargs):

        return self.json_response(

            self.instance_to_dict(self.instance(), self.exclude_fields))

    def PUT(self, request, data, *args, **kwargs):

        instance = self.instance()

        self.update_instance(instance, data, self.exclude_fields)

        instance.full_clean()

        instance.save()

        return self.GET(request, data, *args, **kwargs)

    def DELETE(self, request, data, *args, **kwargs):

        self.instance().delete()

        return self.json_response("")

class CollectionView(JSONRestView):

    method_names = ['GET', 'POST']

    model = None

    exclude_fields = []

    def queryset(self):

        return self.model.objects.all()

    def GET(self, request, data, *args, **kwargs):

        return self.json_response(

            list(self.qs_to_dict_iter(self.queryset(), self.exclude_fields)))

    def POST(self, request, data, *args, **kwargs):

        instance = self.model()

        self.update_instance(instance, data, self.exclude_fields)

        instance.full_clean()

        instance.save()

        return self.json_response(

            self.instance_to_dict(instance, self.exclude_fields))

class UserResourceView(ResourceView):

    """

    Filter resource queryset for request user entries

    """

    def queryset(self):

        return super(UserResourceView,

                     self).queryset().filter(user=self.request.user_uniq)

class UserCollectionView(CollectionView):

    """

    Filter collection queryset for request user entries

    """

    def queryset(self):

        return super(UserCollectionView,

                     self).queryset().filter(user=self.request.user_uniq)

    def POST(self, request, data, *args, **kwargs):

        instance = self.model()

        self.update_instance(instance, data, self.exclude_fields)

        instance.user = request.user_uniq

        instance.full_clean()

        instance.save()

        return self.json_response(

            self.instance_to_dict(instance, self.exclude_fields))