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

    22

class JSONRPCService(JSONRPCServiceBase):

    23

    24

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

    25

        return self.process(request.raw_post_data)

    26

    28

def jsonremote(service):

    29

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

    30

    31

    from jsonrpc import JSONRPCService

    32

    chatservice = JSONRPCService()

    33

    34

    @jsonremote(chatservice)

    35

    def login(request, user_name):

    36

        (...)

    37

    """

    38

    def remotify(func):

    39

        if isinstance(service, JSONRPCService):

    40

            service.add_method(func.__name__, func)

    41

        else:

    42

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

    43

            raise NotImplementedError, emsg

    44

        return func

    45

    return remotify

    46

    47

    48

# FormProcessor provides a mechanism for turning Django Forms into JSONRPC

    49

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

    50

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

    51

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

    52

#

    53

# class SimpleForm(forms.Form):

    54

#     testfield = forms.CharField(max_length=100)

    55

#

    56

# class SimpleForm2(forms.Form):

    57

#     testfield = forms.CharField(max_length=20)

    58

#

    59

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

    60

#                            'processsimpleform2': SimpleForm2})

    61

#

    62

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

    63

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

    64

# part of the app:

    65

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

    66

    67

from django import forms

    68

    70

def builderrors(form):

    71

    d = {}

    72

    for error in form.errors.keys():

    73

        if error not in d:

    74

            d[error] = []

    75

        for errorval in form.errors[error]:

    76

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

    77

    return d

    78

    79

    80

# contains the list of arguments in each field

    81

field_names = {

    82

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

    83

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

    84

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

    85

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

    86

 'DateField': ['input_formats'],

    87

 'DateTimeField': ['input_formats'],

    88

 'TimeField': ['input_formats'],

    89

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

    90

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

    91

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

    92

 'ChoiceField': ['choices'],

    93

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

    94

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

    95

 }

    96

    98

def describe_field_errors(field):

    99

    res = {}

   100

    field_type = field.__class__.__name__

   101

    msgs = {}

   102

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

   103

        msgs[n] = unicode(m)

   104

    res['error_messages'] = msgs

   105

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

   106

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

   107

    return res

   108

   110

def describe_fields_errors(fields, field_names):

   111

    res = {}

   112

    if not field_names:

   113

        field_names = fields.keys()

   114

    for name in field_names:

   115

        field = fields[name]

   116

        res[name] = describe_field_errors(field)

   117

    return res

   118

   120

def describe_field(field):

   121

    res = {}

   122

    field_type = field.__class__.__name__

   123

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

   124

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

   125

        res[fname] = getattr(field, fname)

   126

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

   127

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

   128

    return res

   129

   131

def describe_fields(fields, field_names):

   132

    res = {}

   133

    if not field_names:

   134

        field_names = fields.keys()

   135

    for name in field_names:

   136

        field = fields[name]

   137

        res[name] = describe_field(field)

   138

    return res

   139

   141

class FormProcessor(JSONRPCService):

   142

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

   143

   144

        if _formcls is None:

   145

            JSONRPCService.__init__(self)

   146

            for k in forms.keys():

   147

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

   148

                self.add_method(k, s.__process)

   149

        else:

   150

            JSONRPCService.__init__(self, forms)

   151

            self.formcls = _formcls

   152

   153

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

   154

   155

        f = self.formcls(params)

   156

   157

        if command is None: # just validate

   158

            if not f.is_valid():

   159

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

   160

            return {'success':True}

   161

   162

        elif command.has_key('describe_errors'):

   163

            field_names = command['describe_errors']

   164

            return describe_fields_errors(f.fields, field_names)

   165

   166

        elif command.has_key('describe'):

   167

            field_names = command['describe']

   168

            return describe_fields(f.fields, field_names)

   169

   170

        elif command.has_key('save'):

   171

            if not f.is_valid():

   172

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

   173

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

   174

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

   175

   176

        elif command.has_key('html'):

   177

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

   178

   179

        return "unrecognised command"

   180

   181

   182

   183

   184

# The following is incredibly convenient for saving vast amounts of

   185

# coding, avoiding doing silly things like this:

   186

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

   187

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

   188

#                    ..... }

   189

#

   190

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

   191

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

   192

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

   193

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

   194

#

   195

# use as follows:

   196

#

   197

# jsonservice = JSONRPCService()

   198

#

   199

# @jsonremote(jsonservice)

   200

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

   201

#     l = SomeDjangoModelClass.objects.filter()

   202

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

   203

#

   204

# @jsonremote(jsonservice)

   205

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

   206

#     l = AnotherDjangoModelClass.objects.filter()

   207

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

   208

#

   209

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

   210

# list_some_model and list_another_model part of the django app:

   211

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

   212

   213

from django.core.serializers import serialize

   214

import datetime

   215

from datetime import date

   216

   218

def dict_datetimeflatten(item):

   219

    d = {}

   220

    for k, v in item.items():

   221

        k = str(k)

   222

        if isinstance(v, datetime.date):

   223

            d[k] = str(v)

   224

        elif isinstance(v, dict):

   225

            d[k] = dict_datetimeflatten(v)

   226

        else:

   227

            d[k] = v

   228

    return d

   229

   231

def json_convert(l, fields=None):

   232

    res = []

   233

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

   234

        res.append(dict_datetimeflatten(item))

   235

    return res