# -*- coding: utf-8 -*- # kate: space-indent on; indent-width 4; replace-tabs on; """ * Copyright (C) 2010, Michael "Svedrin" Ziegler * * djExtDirect is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This package is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. """ import json import inspect import functools import traceback from sys import stderr from django.http import HttpResponse from django.conf import settings from django.conf.urls import patterns from django.core.urlresolvers import reverse from django.utils.datastructures import MultiValueDictKeyError from django.core.serializers.json import DjangoJSONEncoder def getname( cls_or_name ): """ If cls_or_name is not a string, return its __name__. """ if type(cls_or_name) not in ( str, unicode ): return cls_or_name.__name__ return cls_or_name class Provider( object ): """ Provider for Ext.Direct. This class handles building API information and routing requests to the appropriate functions, and serializing their response and exceptions - if any. Instantiation: >>> EXT_JS_PROVIDER = Provider( [name="Ext.app.REMOTING_API", autoadd=True] ) If autoadd is True, the api.js will include a line like such:: Ext.Direct.addProvider( Ext.app.REMOTING_API ); After instantiating the Provider, register functions to it like so: >>> @EXT_JS_PROVIDER.register_method("myclass") ... def myview( request, possibly, some, other, arguments ): ... " does something with all those args and returns something " ... return 13.37 Note that those views **MUST NOT** return an HttpResponse but simply the plain result, as the Provider will build a response from whatever your view returns! To be able to access the Provider, include its URLs in an arbitrary URL pattern, like so: >>> from views import EXT_JS_PROVIDER # import our provider instance >>> urlpatterns = patterns( ... # other patterns go here ... ( r'api/', include(EXT_DIRECT_PROVIDER.urls) ), ... ) This way, the Provider will define the URLs "api/api.js" and "api/router". If you then access the "api/api.js" URL, you will get a response such as:: Ext.app.REMOTING_API = { # Ext.app.REMOTING_API is from Provider.name "url": "/mumble/api/router", "type": "remoting", "actions": {"myclass": [{"name": "myview", "len": 4}]} } You can then use this code in ExtJS to define the Provider there. """ def __init__( self, name="Ext.app.REMOTING_API", autoadd=True ): self.name = name self.autoadd = autoadd self.classes = {} def register_method( self, cls_or_name, flags=None ): """ Return a function that takes a method as an argument and adds that to cls_or_name. The flags parameter is for additional information, e.g. formHandler=True. Note: This decorator does not replace the method by a new function, it returns the original function as-is. """ return functools.partial( self._register_method, cls_or_name, flags=flags ) def _register_method( self, cls_or_name, method, flags=None ): """ Actually registers the given function as a method of cls_or_name. """ clsname = getname(cls_or_name) if clsname not in self.classes: self.classes[clsname] = {} if flags is None: flags = {} self.classes[ clsname ][ method.__name__ ] = method method.EXT_argnames = inspect.getargspec( method )[0][1:] method.EXT_len = len( method.EXT_argnames ) method.EXT_flags = flags return method def build_api_dict( self ): actdict = {} for clsname in self.classes: actdict[clsname] = [] for methodname in self.classes[clsname]: methinfo = { "name": methodname, "len": self.classes[clsname][methodname].EXT_len } methinfo.update( self.classes[clsname][methodname].EXT_flags ) actdict[clsname].append( methinfo ) return actdict def get_api_plain( self, request ): """ Introspect the methods and get a JSON description of only the API. """ return HttpResponse( json.dumps({ "url": reverse( self.request ), "type": "remoting", "actions": self.build_api_dict() }, cls=DjangoJSONEncoder), content_type="application/json" ) def get_api( self, request ): """ Introspect the methods and get a javascript description of the API that is meant to be embedded directly into the web site. """ request.META["CSRF_COOKIE_USED"] = True lines = ["%s = %s;" % ( self.name, json.dumps({ "url": reverse( self.request ), "type": "remoting", "actions": self.build_api_dict() }, cls=DjangoJSONEncoder))] if self.autoadd: lines.append( """Ext.Ajax.on("beforerequest", function(conn, options){""" """ if( !options.headers )""" """ options.headers = {};""" """ options.headers["X-CSRFToken"] = Ext.util.Cookies.get("csrftoken");""" """});""" ) lines.append( "Ext.Direct.addProvider( %s );" % self.name ) return HttpResponse( "\n".join( lines ), content_type="text/javascript" ) def request( self, request ): """ Implements the Router part of the Ext.Direct specification. It handles decoding requests, calling the appropriate function (if found) and encoding the response / exceptions. """ request.META["CSRF_COOKIE_USED"] = True # First try to use request.POST, if that doesn't work check for req.body. # The other way round this might make more sense because the case that uses # body is way more common, but accessing request.POST after body # causes issues with Django's test client while accessing body after # request.POST does not. try: jsoninfo = { 'action': request.POST['extAction'], 'method': request.POST['extMethod'], 'type': request.POST['extType'], 'upload': request.POST['extUpload'], 'tid': request.POST['extTID'], } except (MultiValueDictKeyError, KeyError), err: try: rawjson = json.loads( request.body ) except getattr( json, "JSONDecodeError", ValueError ): return HttpResponse( json.dumps({ 'type': 'exception', 'message': 'malformed request', 'where': err.message, "tid": None, # dunno }, cls=DjangoJSONEncoder), content_type="application/json" ) else: return self.process_normal_request( request, rawjson ) else: return self.process_form_request( request, jsoninfo ) def process_normal_request( self, request, rawjson ): """ Process standard requests (no form submission or file uploads). """ if not isinstance( rawjson, list ): rawjson = [rawjson] responses = [] for reqinfo in rawjson: cls, methname, data, rtype, tid = (reqinfo['action'], reqinfo['method'], reqinfo['data'], reqinfo['type'], reqinfo['tid']) if cls not in self.classes: responses.append({ 'type': 'exception', 'message': 'no such action', 'where': cls, "tid": tid, }) continue if methname not in self.classes[cls]: responses.append({ 'type': 'exception', 'message': 'no such method', 'where': methname, "tid": tid, }) continue func = self.classes[cls][methname] if func.EXT_len and len(data) == 1 and type(data[0]) == dict: # data[0] seems to contain a dict with params. check if it does, and if so, unpack args = [] for argname in func.EXT_argnames: if argname in data[0]: args.append( data[0][argname] ) else: args = None break if args: data = args if data is not None: datalen = len(data) else: datalen = 0 if datalen != len(func.EXT_argnames): responses.append({ 'type': 'exception', 'tid': tid, 'message': 'invalid arguments', 'where': 'Expected %d, got %d' % ( len(func.EXT_argnames), len(data) ) }) continue try: if data: result = func( request, *data ) else: result = func( request ) except Exception, err: errinfo = { 'type': 'exception', "tid": tid, } if settings.DEBUG: traceback.print_exc( file=stderr ) errinfo['message'] = err.message errinfo['where'] = traceback.format_exc() else: errinfo['message'] = 'The socket packet pocket has an error to report.' errinfo['where'] = '' responses.append(errinfo) else: responses.append({ "type": rtype, "tid": tid, "action": cls, "method": methname, "result": result }) if len(responses) == 1: return HttpResponse( json.dumps( responses[0], cls=DjangoJSONEncoder ), content_type="application/json" ) else: return HttpResponse( json.dumps( responses, cls=DjangoJSONEncoder ), content_type="application/json" ) def process_form_request( self, request, reqinfo ): """ Router for POST requests that submit form data and/or file uploads. """ cls, methname, rtype, tid = (reqinfo['action'], reqinfo['method'], reqinfo['type'], reqinfo['tid']) if cls not in self.classes: response = { 'type': 'exception', 'message': 'no such action', 'where': cls, "tid": tid, } elif methname not in self.classes[cls]: response = { 'type': 'exception', 'message': 'no such method', 'where': methname, "tid": tid, } else: func = self.classes[cls][methname] try: result = func( request ) except Exception, err: errinfo = { 'type': 'exception', "tid": tid, } if settings.DEBUG: traceback.print_exc( file=stderr ) errinfo['message'] = err.message errinfo['where'] = traceback.format_exc() else: errinfo['message'] = 'The socket packet pocket has an error to report.' errinfo['where'] = '' response = errinfo else: response = { "type": rtype, "tid": tid, "action": cls, "method": methname, "result": result } if reqinfo['upload'] == "true": return HttpResponse( "" % json.dumps(response, cls=DjangoJSONEncoder), content_type="application/json" ) else: return HttpResponse( json.dumps( response, cls=DjangoJSONEncoder ), content_type="application/json" ) def get_urls(self): """ Return the URL patterns. """ pat = patterns('', (r'api.json$', self.get_api_plain ), (r'api.js$', self.get_api ), (r'router/?', self.request ), ) return pat urls = property(get_urls)