0004-jsonresponse-remove-unused-serializers-from-to_json-.patch

Frédéric Péters, 29 juin 2017 08:00

Voir les différences: en ligne côte à côte

Subject: [PATCH 4/5] jsonresponse: remove unused serializers from to_json
 decorator (#17175)

 passerelle/apps/bdp/views.py                    |  8 ++--
 passerelle/apps/choosit/views.py                |  8 ++--
 passerelle/apps/clicrdv/views.py                | 22 +++++-----
 passerelle/apps/csvdatasource/views.py          |  4 +-
 passerelle/contrib/agoraplus/views.py           | 26 +++++------
 passerelle/contrib/fake_family/views.py         |  4 +-
 passerelle/contrib/meyzieu_newsletters/views.py | 12 ++---
 passerelle/contrib/solis_apa/views.py           |  8 ++--
 passerelle/contrib/stub_invoices/views.py       | 16 +++----
 passerelle/contrib/teamnet_axel/views.py        | 10 ++---
 passerelle/utils/jsonresponse.py                | 58 +++----------------------
 passerelle/views.py                             |  3 +-
 tests/test_jsonresponse.py                      | 37 +++++-----------
 13 files changed, 78 insertions(+), 138 deletions(-)

         model = Bdp
         @utils.protected_api('can_access')
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, *args, **kwargs):
             text_key = request.GET.get('text_key')
             id_key = request.GET.get('id_key')
-...
                     r['text'] = r[text_key]
                 elif 'text' not in r:
                     r['text'] = r['id']
             return resources
             return {'data': resources}
     class PostAdherentView(View, SingleObjectMixin):
-...
             raise Http404
         @utils.protected_api('can_access')
         @utils.to_json('api')
         @utils.to_json()
         def post(self, request, *args, **kwargs):
             data = json.loads(request.body) # JSON w.c.s. formdata
             date_de_naissance = data['fields'].get('date_de_naissance')
-...
                 'bibliotheque': {'id': bibliotheque_id},
                 'abonnements': abonnements,
+            }
             return self.get_object().post_api('adherents', adherent)
             return {'data': self.get_object().post_api('adherents', adherent)}
     class BdpDetailView(DetailView):

         def dispatch(self, request, *args, **kwargs):
             return super(ChoositRegisterView, self).dispatch(request, *args, **kwargs)
         @utils.to_json('api')
         @utils.to_json()
         @method_decorator(csrf_exempt)
         def get(self, request, *args, **kwargs):
             user = request.GET.get('user')
             assert user, 'missing user parameter'
             return self.get_object().get_list(user)
             return {'data': self.get_object().get_list(user)}
         @utils.to_json('api')
         @utils.to_json()
         def post(self, request, *args, **kwargs):
             user = request.GET.get('user')
             assert user, 'missing user parameter'
             data = json.loads(request.body)
             assert isinstance(data, list), 'body must be a JSON list'
             return self.get_object().post(user, data)
             return {'data': self.get_object().post(user, data)}

         """
         model = ClicRdv
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, intervention_id, *args, **kwargs):
             return self.get_object().get_datetimes(intervention_id)
             return {'data': self.get_object().get_datetimes(intervention_id)}
     class DatesView(View, SingleObjectMixin):
-...
         """
         model = ClicRdv
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, intervention_id, *args, **kwargs):
             return self.get_object().get_dates(intervention_id)
             return {'data': self.get_object().get_dates(intervention_id)}
     class TimesView(View, SingleObjectMixin):
-...
         """
         model = ClicRdv
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, intervention_id, date, *args, **kwargs):
             return self.get_object().get_times(intervention_id, date)
             return {'data': self.get_object().get_times(intervention_id, date)}
     class CreateAppointmentView(View, SingleObjectMixin):
-...
         model = ClicRdv
         @utils.protected_api('can_manage_appointment')
         @utils.to_json('api')
         @utils.to_json()
         def post(self, request, intervention_id=None, *args, **kwargs):
             if intervention_id is None:
                 intervention_id = self.request.GET.get('intervention')
             data = json.loads(request.body)
             return self.get_object().create_appointment(
             return {'data': self.get_object().create_appointment(
                     intervention_id,
                     self.request.GET.get('websource'),
                     data)
                     data)}
     class CancelAppointmentView(View, SingleObjectMixin):
-...
         model = ClicRdv
         @utils.protected_api('can_manage_appointment')
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, appointment_id, *args, **kwargs):
             return self.get_object().cancel(appointment_id)
             return {'data': self.get_object().cancel(appointment_id)}

         @utils.protected_api('can_access')
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, *args, **kwargs):
             obj = self.get_object()
             filters = self._filters_builder(request)
             return obj.get_data(filters)
             return {'data': obj.get_data(filters)}
     class NewQueryView(CreateView):

         def get_data(self, request, *args, **kwargs):
             raise NotImplementedError
         @utils.to_json('api')
         @utils.to_json()
         @utils.protected_api('can_access')
         def get(self, request, *args, **kwargs):
             self.object = self.get_object()
             self.set_user_from_request(request)
             self.family = None
             return self.get_data(request, *args, **kwargs)
             return {'data': self.get_data(request, *args, **kwargs)}
     class PingView(DetailView):
-...
     class LinkView(GenericDetailView):
         model = AgoraPlus
         @utils.to_json('api')
         @utils.to_json()
         @utils.protected_api('can_access')
         def get(self, request, *args, **kwargs):
             agoraplus = self.get_object()
-...
                                                    name_id=name_id,
                                                    defaults={'login': login, 'password': password})
             logger.info('link created: NameID:%r with Agora login:%r', name_id, login)
             return True
             return {'data': True}
     class UnlinkView(GenericDetailView):
         model = AgoraPlus
         @utils.to_json('api')
         @utils.to_json()
         @utils.protected_api('can_access')
         def get(self, request, *args, **kwargs):
             agoraplus = self.get_object()
-...
             name_id = request.GET['NameID']
             provision_roles(name_id, 'DELETE')
             AgoraPlusLink.objects.filter(resource=agoraplus, name_id=name_id).delete()
             return True
             return {'data': True}
     class FamilyView(DetailView):
-...
         def post_data(self, name_id, formdata):
             raise NotImplementedError
         @utils.to_json('api')
         @utils.to_json()
         @utils.protected_api('can_access_sas')
         def post(self, request, *args, **kwargs):
             self.object = self.get_object()
-...
             name_id = formdata.get('NameID')
             if not name_id:
                 raise AgoraAPIError('missing NameID parameter')
             return self.post_data(name_id, formdata)
             return {'data': self.post_data(name_id, formdata)}
     class SasFamilyView(SasView):
-...
         def post_data(self, formdata):
             raise NotImplementedError
         @utils.to_json('api')
         @utils.to_json()
         @utils.protected_api('can_access_sas')
         def post(self, request, *args, **kwargs):
             self.object = self.get_object()
             self.set_user_from_request(request)
             data = json.loads(request.body)
             formdata = Formdata(data)
             return self.post_data(formdata)
             return {'data': self.post_data(formdata)}
     class IncomesDeclarationView(PostFormdataView):
-...
         def dispatch(self, *args, **kwargs):
             return super(InvoicePayView, self).dispatch(*args, **kwargs)
         @utils.to_json('api')
         @utils.to_json()
         @utils.protected_api('can_access')
         def post(self, request, *args, **kwargs):
             self.object = self.get_object()
             data = json.loads(request.body)
             return self.object.pay_invoice(kwargs['invoice_id'], data['transaction_id'],
                                 data['transaction_date'])
             return {'data': self.object.pay_invoice(kwargs['invoice_id'], data['transaction_id'],
                                 data['transaction_date'])}
     class InvoiceView(DetailView):

         def get_data(self, request, *args, **kwargs):
             raise NotImplementedError
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, *args, **kwargs):
             self.resource = self.get_object()
             return self.get_data(request, *args, **kwargs)
             return {'data': self.get_data(request, *args, **kwargs)}
     class LinkView(DetailView):

             raise NotImplementedError
         @utils.protected_api('can_access')
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, *args, **kwargs):
             return self.get_data(request, *args, **kwargs)
             return {'data': self.get_data(request, *args, **kwargs)}
     class NewslettersTypesView(DetailView):
-...
             return super(NewslettersSubscriptionsView, self).dispatch(*args, **kwargs)
         @utils.protected_api('can_access')
         @utils.to_json('api')
         @utils.to_json()
         def delete(self, request, *args, **kwargs):
             email = request.GET.get('email')
             assert email, 'missing email parameter'
-...
             subscriptions = obj.get_subscriptions(email)
             for sub in subscriptions:
                 sub['transports'] = []
             return obj.set_subscriptions(email, subscriptions)
             return {'data': obj.set_subscriptions(email, subscriptions)}
         @utils.protected_api('can_access')
         @utils.to_json('api')
         @utils.to_json()
         def post(self, request, *args, **kwargs):
             email = request.GET.get('email')
             assert email, 'missing email parameter'
             data = json.loads(request.body)
             return self.get_object().set_subscriptions(email, data)
             return {'data': self.get_object().set_subscriptions(email, data)}
         def get_data(self, request, *args, **kwargs):
             return self.get_object().get_subscriptions(request.GET.get('email'))

             raise NotImplementedError
         @utils.protected_api('can_access')
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, *args, **kwargs):
             return self.get_data(request, *args, **kwargs)
             return {'data': self.get_data(request, *args, **kwargs)}
         def _get_params(self, request, *params):
             return [ request.GET.get(item, None) for item in params]
-...
             return super(IntegrationView, self).dispatch(request, *args, **kwargs)
         @utils.protected_api('can_access')
         @utils.to_json('api')
         @utils.to_json()
         def post(self, request, *args, **kwargs):
             data = request.body
             return self.get_object().import_flow(data)
             return {'data': self.get_object().import_flow(data)}

     class InvoicesView(DetailView):
         model = StubInvoicesConnector
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, *args, **kwargs):
             return [x for x in self.get_object().get_invoices() if not x.get('payment_date')]
             return {'data': [x for x in self.get_object().get_invoices() if not x.get('payment_date')]}
     class HistoryInvoicesView(DetailView):
         model = StubInvoicesConnector
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, *args, **kwargs):
             return [x for x in self.get_object().get_invoices() if x.get('payment_date')]
             return {'data': [x for x in self.get_object().get_invoices() if x.get('payment_date')]}
     class InvoiceView(DetailView):
         model = StubInvoicesConnector
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, *args, **kwargs):
             return self.get_object().get_invoice(kwargs.get('invoice_id'))
             return {'data': self.get_object().get_invoice(kwargs.get('invoice_id'))}
     class InvoicePDFView(DetailView):
-...
         def dispatch(self, *args, **kwargs):
             return super(InvoicePayView, self).dispatch(*args, **kwargs)
         @utils.to_json('api')
         @utils.to_json()
         @utils.protected_api('can_access')
         def post(self, request, *args, **kwargs):
             return utils.response_for_json(request, {'data': None})
             return {'data': None}

             raise NotImplementedError
         @utils.protected_api('can_access')
         @utils.to_json('api')
         @utils.to_json()
         def get(self, request, *args, **kwargs):
             self.object = self.get_object()
             return self.get_data(request, *args, **kwargs)
             return {'data': self.get_data(request, *args, **kwargs)}
     class PingView(DetailView):
-...
         def dispatch(self, *args, **kwargs):
             return super(InvoicePayView, self).dispatch(*args, **kwargs)
         @utils.to_json('api')
         @utils.to_json()
         @utils.protected_api('can_access')
         def post(self, request, *args, **kwargs):
             self.object = self.get_object()
             data = json.loads(request.body)
             return self.object.pay_invoice(kwargs['regie_id'],
             return {'data': self.object.pay_invoice(kwargs['regie_id'],
                         kwargs['invoice_id'], data['transaction_id'],
                         data['transaction_date'])
                         data['transaction_date'])}

     import functools
     import logging
     import re
     from collections import Iterable
     from django.http import HttpResponse, Http404, HttpResponseBadRequest
     from django.conf import settings
-...
     class to_json(object):
         def __init__(self, serializer_type, error_code=500, wrap_response=True, **kwargs):
             """
             serializer_types:
                 * api - serialize buildin objects (dict, list, etc) in strict api
                 * objects - serialize list of region in strict api
                 * plain - just serialize result of function, do not wrap response and do not handle exceptions
             """
             self.serializer_type = serializer_type
         def __init__(self, error_code=500, **kwargs):
             self.method = None
             self.error_code = error_code
             self.kwargs = kwargs
             self.wrap_response = wrap_response
             if 'cls' not in self.kwargs:
                 self.kwargs['cls'] = DjangoJSONEncoder
-...
                     return self.method(f, *args, **kwargs)
                 if not args:
                     if self.serializer_type == 'plain':
                         self.method = self.plain_func
                     else:
                         self.method = self.api_func
                     self.method = self.api_func
                 if getattr(getattr(args[0], f.__name__, None), "im_self", False):
                     if self.serializer_type == 'plain':
                         self.method = self.plain_method
                     else:
                         self.method = self.api_method
                     self.method = self.api_method
                 else:
                     if self.serializer_type == 'plain':
                         self.method = self.plain_func
                     else:
                         self.method = self.api_func
                     self.method = self.api_func
                 return self.method(f, *args, **kwargs)
             return wrapper
         def obj_to_response(self, req, obj):
             if self.serializer_type == 'objects':
                 if isinstance(obj, Iterable):
                     obj = [o.serialize(req) if obj else None for o in obj]
                 elif obj:
                     obj = obj.serialize(req)
                 else:
                     obj = None
             if self.wrap_response:
                 d = {"err": 0}
                 d.update({"data": obj})
                 return d
             else:
                 if isinstance(obj, dict) and not 'err' in obj:
                     obj['err'] = 0
                 return obj
             if isinstance(obj, dict) and not 'err' in obj:
                 obj['err'] = 0
             return obj
         def err_to_response(self, err):
             if hasattr(err, "__module__"):
-...
                     status = self.error_code
             return self.render_data(req, data, status)
         def plain_method(self, f, *args, **kwargs):
             data = f(*args, **kwargs)
             if isinstance(data, HttpResponse):
                 return data
             return self.render_data(args[1], data)
         def plain_func(self, f, *args, **kwargs):
             data = f(*args, **kwargs)
             if isinstance(data, HttpResponse):
                 return data
             return self.render_data(args[0], data)

             return self.endpoint(request, **self.get_params(request, *args, **kwargs))
         def get(self, request, *args, **kwargs):
             json_decorator = to_json('api', wrap_response=False)
             if self.endpoint.endpoint_info.pattern:
                 pattern = url(self.endpoint.endpoint_info.pattern, self.endpoint)
                 match = pattern.resolve(kwargs.get('rest') or '')
-...
                 kwargs['other_params'] = match.kwargs
             elif kwargs.get('rest'):
                 raise Http404()
             return json_decorator(self.perform)(request, *args, **kwargs)
             return to_json()(self.perform)(request, *args, **kwargs)
         def post(self, request, *args, **kwargs):
             return self.get(request, *args, **kwargs)

             return 'log as warning exception'
     @to_json('api')
     @to_json()
     def wrapped_exception(req, *args, **kwargs):
         raise WrappedException
     @to_json('api')
     @to_json()
     def log_as_warning_exception(req, *args, **kwargs):
         raise LogAsWarningException
     @to_json('api')
     @to_json()
     def http404_exception(req, *args, **kwargs):
         raise Http404
     @to_json('api')
     @to_json()
     def doesnotexist_exception(req, *args, **kwargs):
         raise ObjectDoesNotExist
     @to_json('api')
     @to_json()
     def permissiondenied_exception(req, *args, **kwargs):
         raise PermissionDenied
-...
     def test_jsonresponse_error_header():
         request = RequestFactory()
         req = request.get('/')
         @to_json('api')
         @to_json()
         def test_func(req):
             return {"test": "un test"}
         result = test_func(req)
         assert result.status_code == 200
         data = json.loads(result.content)
         assert 'err' in data
         assert data['err'] == 0
         assert 'data' in data
         assert 'test' in data['data']
         assert data['data']['test'] == 'un test'
         @to_json('api')
         assert data == {'test': 'un test', 'err': 0}
         @to_json()
         def test_func(req):
             class CustomException(Exception):
                 http_status = 200
-...
         response = http404_exception(request.get('/'))
         assert response.status_code == 404
     def test_jsonresponse_without_wrapping():
         request = RequestFactory()
         req = request.get('/')
         @to_json('api', wrap_response=False)
         def test_func(req):
             return {"foo": "bar"}
         result = test_func(req)
         data = json.loads(result.content)
         assert data == {"foo": "bar", "err": 0}
     def test_jsonresponse_with_callback():
         request = RequestFactory()
         req = request.get('/?callback=myfunc')
         @to_json('api')
         @to_json()
         def test_func(req):
             return {"foo": "bar"}
         result = test_func(req)
-...
         assert 'application/javascript' in content_type
         assert result.content.startswith('myfunc(')
         args = json.loads(result.content[7:-2])
         assert args['err'] == 0
         assert args['data'] == {"foo": "bar"}
         assert args == {'foo': 'bar', 'err': 0}
     def test_jsonresponse_with_wrong_callback():
         request = RequestFactory()
         req = request.get('/?callback=myfunc()')
         @to_json('api')
         @to_json()
         def test_func(req):
             return {"foo": "bar"}
         result = test_func(req)
+    -

Projet

Général

Profil

Produits Entr'ouvert » Passerelle

0004-jsonresponse-remove-unused-serializers-from-to_json-.patch