1

# jsonrpc.py

     2

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

     3

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

     4

     5

from __future__ import absolute_import

     6

import datetime

     7

from builtins import str as text

     8

     9

from django.core.serializers import serialize

    10

    11

    12

from svgui.pyjs.jsonrpc.jsonrpc import JSONRPCServiceBase

    13

# JSONRPCService and jsonremote are used in combination to drastically

    14

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

    15

#

    16

# jsonservice = JSONRPCService()

    17

#

    18

# @jsonremote(jsonservice)

    19

# def test(request, echo_param):

    20

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

    21

#

    22

# dump jsonservice into urlpatterns:

    23

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

    24

    25

    26

class JSONRPCService(JSONRPCServiceBase):

    27

    28

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

    29

        return self.process(request.raw_post_data)

    30

    31

    32

def jsonremote(service):

    33

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

    34

    35

    from jsonrpc import JSONRPCService

    36

    chatservice = JSONRPCService()

    37

    38

    @jsonremote(chatservice)

    39

    def login(request, user_name):

    40

        (...)

    41

    """

    42

    def remotify(func):

    43

        if isinstance(service, JSONRPCService):

    44

            service.add_method(func.__name__, func)

    45

        else:

    46

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

    47

            raise NotImplementedError(emsg)

    48

        return func

    49

    return remotify

    50

    51

    52

# FormProcessor provides a mechanism for turning Django Forms into JSONRPC

    53

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

    54

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

    55

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

    56

#

    57

# class SimpleForm(forms.Form):

    58

#     testfield = forms.CharField(max_length=100)

    59

#

    60

# class SimpleForm2(forms.Form):

    61

#     testfield = forms.CharField(max_length=20)

    62

#

    63

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

    64

#                            'processsimpleform2': SimpleForm2})

    65

#

    66

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

    67

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

    68

# part of the app:

    69

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

    70

    71

    72

def builderrors(form):

    73

    d = {}

    74

    for error in form.errors.keys():

    75

        if error not in d:

    76

            d[error] = []

    77

        for errorval in form.errors[error]:

    78

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

    79

    return d

    80

    81

    82

# contains the list of arguments in each field

    83

field_names = {

    84

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

    85

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

    86

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

    87

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

    88

    'DateField': ['input_formats'],

    89

    'DateTimeField': ['input_formats'],

    90

    'TimeField': ['input_formats'],

    91

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

    92

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

    93

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

    94

    'ChoiceField': ['choices'],

    95

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

    96

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

    97

}

    98

    99

   100

def describe_field_errors(field):

   101

    res = {}

   102

    field_type = field.__class__.__name__

   103

    msgs = {}

   104

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

   105

        msgs[n] = text(m)

   106

    res['error_messages'] = msgs

   107

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

   108

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

   109

    return res

   110

   111

   112

def describe_fields_errors(fields, field_names):

   113

    res = {}

   114

    if not field_names:

   115

        field_names = fields.keys()

   116

    for name in field_names:

   117

        field = fields[name]

   118

        res[name] = describe_field_errors(field)

   119

    return res

   120

   121

   122

def describe_field(field):

   123

    res = {}

   124

    field_type = field.__class__.__name__

   125

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

   126

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

   127

        res[fname] = getattr(field, fname)

   128

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

   129

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

   130

    return res

   131

   132

   133

def describe_fields(fields, field_names):

   134

    res = {}

   135

    if not field_names:

   136

        field_names = fields.keys()

   137

    for name in field_names:

   138

        field = fields[name]

   139

        res[name] = describe_field(field)

   140

    return res

   141

   142

   143

class FormProcessor(JSONRPCService):

   144

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

   145

   146

        if _formcls is None:

   147

            JSONRPCService.__init__(self)

   148

            for k in forms.keys():

   149

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

   150

                self.add_method(k, s.__process)

   151

        else:

   152

            JSONRPCService.__init__(self, forms)

   153

            self.formcls = _formcls

   154

   155

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

   156

   157

        f = self.formcls(params)

   158

   159

        if command is None:  # just validate

   160

            if not f.is_valid():

   161

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

   162

            return {'success': True}

   163

   164

        elif 'describe_errors' in command:

   165

            field_names = command['describe_errors']

   166

            return describe_fields_errors(f.fields, field_names)

   167

   168

        elif 'describe' in command:

   169

            field_names = command['describe']

   170

            return describe_fields(f.fields, field_names)

   171

   172

        elif 'save' in command:

   173

            if not f.is_valid():

   174

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

   175

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

   176

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

   177

   178

        elif 'html' in command:

   179

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

   180

   181

        return "unrecognised command"

   182

   183

# The following is incredibly convenient for saving vast amounts of

   184

# coding, avoiding doing silly things like this:

   185

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

   186

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

   187

#                    ..... }

   188

#

   189

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

   190

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

   191

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

   192

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

   193

#

   194

# use as follows:

   195

#

   196

# jsonservice = JSONRPCService()

   197

#

   198

# @jsonremote(jsonservice)

   199

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

   200

#     l = SomeDjangoModelClass.objects.filter()

   201

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

   202

#

   203

# @jsonremote(jsonservice)

   204

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

   205

#     l = AnotherDjangoModelClass.objects.filter()

   206

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

   207

#

   208

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

   209

# list_some_model and list_another_model part of the django app:

   210

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

   211

   212

   213

def dict_datetimeflatten(item):

   214

    d = {}

   215

    for k, v in item.items():

   216

        k = str(k)

   217

        if isinstance(v, datetime.date):

   218

            d[k] = str(v)

   219

        elif isinstance(v, dict):

   220

            d[k] = dict_datetimeflatten(v)

   221

        else:

   222

            d[k] = v

   223

    return d

   224

   225

   226

def json_convert(l, fields=None):

   227

    res = []

   228

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

   229

        res.append(dict_datetimeflatten(item))

   230

    return res