1 # jsonrpc.py

     2 #   original code: http://trac.pyworks.org/pyjamas/wiki/DjangoWithPyJamas

     3 #   also from: http://www.pimentech.fr/technologies/outils

     4 from django.utils import simplejson

     5 from django.http import HttpResponse

     6 import sys

     7 

     8 from pyjs.jsonrpc import JSONRPCServiceBase

     9 # JSONRPCService and jsonremote are used in combination to drastically

    10 # simplify the provision of JSONRPC services.  use as follows:

    11 #

    12 # jsonservice = JSONRPCService()

    13 #

    14 # @jsonremote(jsonservice)

    15 # def test(request, echo_param):

    16 #     return "echoing the param back: %s" % echo_param

    17 #

    18 # dump jsonservice into urlpatterns:

    19 #  (r'^service1/$', 'djangoapp.views.jsonservice'),

    20 

    21 class JSONRPCService(JSONRPCServiceBase):

    22     

    23     def __call__(self, request, extra=None):

    24         return self.process(request.raw_post_data)

    25 

    26 def jsonremote(service):

    27     """Make JSONRPCService a decorator so that you can write :

    28     

    29     from jsonrpc import JSONRPCService

    30     chatservice = JSONRPCService()

    31 

    32     @jsonremote(chatservice)

    33     def login(request, user_name):

    34         (...)

    35     """

    36     def remotify(func):

    37         if isinstance(service, JSONRPCService):

    38             service.add_method(func.__name__, func)

    39         else:

    40             emsg = 'Service "%s" not found' % str(service.__name__)

    41             raise NotImplementedError, emsg

    42         return func

    43     return remotify

    44 

    45 

    46 # FormProcessor provides a mechanism for turning Django Forms into JSONRPC

    47 # Services.  If you have an existing Django app which makes prevalent

    48 # use of Django Forms it will save you rewriting the app.

    49 # use as follows.  in djangoapp/views.py :

    50 #

    51 # class SimpleForm(forms.Form):

    52 #     testfield = forms.CharField(max_length=100)

    53 #

    54 # class SimpleForm2(forms.Form):

    55 #     testfield = forms.CharField(max_length=20)

    56 #

    57 # processor = FormProcessor({'processsimpleform': SimpleForm,

    58 #                            'processsimpleform2': SimpleForm2})

    59 #

    60 # this will result in a JSONRPC service being created with two

    61 # RPC functions.  dump "processor" into urlpatterns to make it

    62 # part of the app:

    63 #  (r'^formsservice/$', 'djangoapp.views.processor'),

    64 

    65 from django import forms 

    66 

    67 def builderrors(form):

    68     d = {}

    69     for error in form.errors.keys():

    70         if error not in d:

    71             d[error] = []

    72         for errorval in form.errors[error]:

    73             d[error].append(unicode(errorval))

    74     return d

    75 

    76 

    77 # contains the list of arguments in each field

    78 field_names = {

    79  'CharField': ['max_length', 'min_length'],

    80  'IntegerField': ['max_value', 'min_value'],

    81  'FloatField': ['max_value', 'min_value'],

    82  'DecimalField': ['max_value', 'min_value', 'max_digits', 'decimal_places'],

    83  'DateField': ['input_formats'],

    84  'DateTimeField': ['input_formats'],

    85  'TimeField': ['input_formats'],

    86  'RegexField': ['max_length', 'min_length'], # sadly we can't get the expr

    87  'EmailField': ['max_length', 'min_length'],

    88  'URLField': ['max_length', 'min_length', 'verify_exists', 'user_agent'],

    89  'ChoiceField': ['choices'],

    90  'FilePathField': ['path', 'match', 'recursive', 'choices'],

    91  'IPAddressField': ['max_length', 'min_length'],

    92  }

    93 

    94 def describe_field_errors(field):

    95     res = {}

    96     field_type = field.__class__.__name__

    97     msgs = {}

    98     for n, m in field.error_messages.items():

    99         msgs[n] = unicode(m)

   100     res['error_messages'] = msgs

   101     if field_type in ['ComboField', 'MultiValueField', 'SplitDateTimeField']:

   102         res['fields'] = map(describe_field, field.fields)

   103     return res

   104 

   105 def describe_fields_errors(fields, field_names):

   106     res = {}

   107     if not field_names:

   108         field_names = fields.keys()

   109     for name in field_names:

   110         field = fields[name]

   111         res[name] = describe_field_errors(field)

   112     return res

   113 

   114 def describe_field(field):

   115     res = {}

   116     field_type = field.__class__.__name__

   117     for fname in field_names.get(field_type, []) + \

   118           ['help_text', 'label', 'initial', 'required']:

   119         res[fname] = getattr(field, fname)

   120     if field_type in ['ComboField', 'MultiValueField', 'SplitDateTimeField']:

   121         res['fields'] = map(describe_field, field.fields)

   122     return res

   123 

   124 def describe_fields(fields, field_names):

   125     res = {}

   126     if not field_names:

   127         field_names = fields.keys()

   128     for name in field_names:

   129         field = fields[name]

   130         res[name] = describe_field(field)

   131     return res

   132 

   133 class FormProcessor(JSONRPCService):

   134     def __init__(self, forms, _formcls=None):

   135 

   136         if _formcls is None:

   137             JSONRPCService.__init__(self)

   138             for k in forms.keys():

   139                 s  = FormProcessor({}, forms[k])

   140                 self.add_method(k, s.__process)

   141         else:

   142             JSONRPCService.__init__(self, forms)

   143             self.formcls = _formcls

   144 

   145     def __process(self, request, params, command=None):

   146 

   147         f = self.formcls(params)

   148 

   149         if command is None: # just validate

   150             if not f.is_valid():

   151                 return {'success':False, 'errors': builderrors(f)}

   152             return {'success':True}

   153 

   154         elif command.has_key('describe_errors'):

   155             field_names = command['describe_errors']

   156             return describe_fields_errors(f.fields, field_names)

   157 

   158         elif command.has_key('describe'):

   159             field_names = command['describe']

   160             return describe_fields(f.fields, field_names)

   161 

   162         elif command.has_key('save'):

   163             if not f.is_valid():

   164                 return {'success':False, 'errors': builderrors(f)}

   165             instance = f.save() # XXX: if you want more, over-ride save.

   166             return {'success': True, 'instance': json_convert(instance) }

   167 

   168         elif command.has_key('html'):

   169             return {'success': True, 'html': f.as_table()}

   170 

   171         return "unrecognised command"

   172 

   173 

   174 

   175 

   176 # The following is incredibly convenient for saving vast amounts of

   177 # coding, avoiding doing silly things like this:

   178 #     jsonresult = {'field1': djangoobject.field1,

   179 #                   'field2': djangoobject.date.strftime('%Y.%M'),

   180 #                    ..... }

   181 #

   182 # The date/time flatten function is there because JSONRPC doesn't

   183 # support date/time objects or formats, so conversion to a string

   184 # is the most logical choice.  pyjamas, being python, can easily

   185 # be used to parse the string result at the other end.

   186 #

   187 # use as follows:

   188 #

   189 # jsonservice = JSONRPCService()

   190 #

   191 # @jsonremote(jsonservice)

   192 # def list_some_model(request, start=0, count=10):

   193 #     l = SomeDjangoModelClass.objects.filter()

   194 #     res = json_convert(l[start:end])

   195 #

   196 # @jsonremote(jsonservice)

   197 # def list_another_model(request, start=0, count=10):

   198 #     l = AnotherDjangoModelClass.objects.filter()

   199 #     res = json_convert(l[start:end])

   200 #

   201 # dump jsonservice into urlpatterns to make the two RPC functions,

   202 # list_some_model and list_another_model part of the django app:

   203 #  (r'^service1/$', 'djangoapp.views.jsonservice'),

   204 

   205 from django.core.serializers import serialize

   206 import datetime

   207 from datetime import date

   208 

   209 def dict_datetimeflatten(item):

   210     d = {}

   211     for k, v in item.items():

   212         k = str(k)

   213         if isinstance(v, datetime.date):

   214             d[k] = str(v)

   215         elif isinstance(v, dict):

   216             d[k] = dict_datetimeflatten(v)

   217         else:

   218             d[k] = v

   219     return d

   220 

   221 def json_convert(l, fields=None):

   222     res = []

   223     for item in serialize('python', l, fields=fields):

   224         res.append(dict_datetimeflatten(item))

   225     return res

   226