0001-general-add-generic-endpoint-view-11204.patch

Frédéric Péters, 05 juin 2016 10:07

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

Subject: [PATCH] general: add generic endpoint view (#11204)

 passerelle/apps/base_adresse/models.py             |  66 +++++++++++++
 .../base_adresse/base_adresse_detail.html          |   8 +-
 passerelle/apps/base_adresse/urls.py               |   3 -
 passerelle/apps/base_adresse/views.py              | 106 +++------------------
 passerelle/urls.py                                 |   7 +-
 passerelle/views.py                                |  27 +++++-
 6 files changed, 111 insertions(+), 106 deletions(-)

     import requests
     import urllib
     import urlparse
     from django.core.urlresolvers import reverse
     from django.db import models
     from django.utils.translation import ugettext_lazy as _
     from passerelle.base.models import BaseResource
     from passerelle.utils.api import endpoint
     class BaseAdresse(BaseResource):
-...
         @classmethod
         def get_icon_class(cls):
             return 'gis'
         @endpoint
         def search(self, request, q, format='json'):
             if format != 'json':
                 raise NotImplementedError()
             scheme, netloc, path, params, query, fragment = urlparse.urlparse(self.service_url)
             path = '/search/'
             query = urllib.urlencode({'q': q, 'limit': 1})
             url = urlparse.urlunparse((scheme, netloc, path, params, query, fragment))
             result_response = requests.get(url)
             result = []
             for feature in result_response.json().get('features'):
                 if not feature['geometry']['type'] == 'Point':
                     continue # skip unknown
                 result.append({
                     'lon': str(feature['geometry']['coordinates'][0]),
                     'lat': str(feature['geometry']['coordinates'][1]),
                     'display_name': feature['properties']['label'],
                 })
                 break
             return result
         @endpoint
         def reverse(self, request, lat, lon, format='json'):
             response_format = 'json'
             if format != 'json':
                 raise NotImplementedError()
             scheme, netloc, path, params, query, fragment = urlparse.urlparse(self.service_url)
             path = '/reverse/'
             query = urllib.urlencode({'lat': lat, 'lon': lon})
             url = urlparse.urlunparse((scheme, netloc, path, params, query, fragment))
             result_response = requests.get(url)
             result = None
             for feature in result_response.json().get('features'):
                 if not feature['geometry']['type'] == 'Point':
                     continue # skip unknown
                 result = {}
                 result['lon'] = str(feature['geometry']['coordinates'][0])
                 result['lat'] = str(feature['geometry']['coordinates'][1])
                 result['address'] = {'country': 'France'}
                 for prop in feature['properties']:
                     if prop in ('city', 'postcode'):
                         result['address'][prop] = feature['properties'][prop]
                     elif prop == 'housenumber':
                         result['address']['house_number'] = feature['properties'][prop]
                     elif prop == 'label':
                         result['display_name'] = feature['properties'][prop]
                     elif prop == 'name':
                         house_number = feature['properties'].get('housenumber')
                         value = feature['properties'][prop]
                         if house_number and value.startswith(house_number):
                             value = value[len(house_number):].strip()
                         result['address']['road'] = value
             return result

     </p>
     <ul>
     <li>{% trans 'Geocoding:' %} <a href="{% url 'base_adresse-search' slug=object.slug %}?q=169 rue du chateau, paris&format=json"
             >{{ site_base_uri }}{% url 'base_adresse-search' slug=object.slug %}</a>?q=<i>q</i>&amp;format=json</li>
     <li>{% trans 'Reverse geocoding:' %} <a href="{% url 'base_adresse-reverse' slug=object.slug %}?lat=48.833708&amp;lon=2.323349&amp;format=json"
             >{{ site_base_uri }}{% url 'base_adresse-reverse' slug=object.slug %}</a>?lat=<i>lat</i>&amp;lon=<i>lon</i>&amp;format=json</li>
     <li>{% trans 'Geocoding:' %} <a href="search?q=169 rue du chateau, paris&format=json"
       >{{ site_base_uri }}{{ object.get_absolute_url }}search</a>?q=<i>q</i>&amp;format=json</li>
     <li>{% trans 'Reverse geocoding:' %} <a href="reverse?lat=48.833708&amp;lon=2.323349&amp;format=json"
       >{{ site_base_uri }}{{ object.get_absolute_url }}reverse</a>?lat=<i>lat</i>&amp;lon=<i>lon</i>&amp;format=json</li>
     </ul>
     </div>

     urlpatterns = patterns('',
         url(r'^(?P<slug>[\w,-]+)/$', BaseAdresseDetailView.as_view(), name='base_adresse-view'),
         url(r'^(?P<slug>[\w,-]+)/search$', SearchView.as_view(), name='base_adresse-search'),
         url(r'^(?P<slug>[\w,-]+)/search/(?P<path>.*)$', SearchPathView.as_view(), name='base_adresse-path-search'),
         url(r'^(?P<slug>[\w,-]+)/reverse$', ReverseView.as_view(), name='base_adresse-reverse'),
+    )

     import requests
     import urllib
     import urlparse
     from django.http import HttpResponseBadRequest
     from django.views.generic.base import View
     from django.views.generic.detail import SingleObjectMixin, DetailView
     from passerelle import utils
     from django.views.generic.detail import DetailView
     from passerelle.views import GenericEndpointView
     from .models import BaseAdresse
-...
             return context
     class SearchView(View, SingleObjectMixin):
         model = BaseAdresse
         def get_query(self, request, *args, **kwargs):
             if not 'q' in request.GET:
                 return HttpResponseBadRequest('missing parameter')
             return request.GET['q']
         def get(self, request, *args, **kwargs):
             response_format = 'json'
             if 'format' in request.GET:
                 response_format = request.GET['format']
             if response_format != 'json':
                 raise NotImplementedError()
             scheme, netloc, path, params, query, fragment = urlparse.urlparse(
                     self.get_object().service_url)
             path = '/search/'
             query = urllib.urlencode({'q': self.get_query(request, *args, **kwargs), 'limit': 1})
             url = urlparse.urlunparse((scheme, netloc, path, params, query, fragment))
             result_response = requests.get(url)
             result = []
             for feature in result_response.json().get('features'):
                 if not feature['geometry']['type'] == 'Point':
                     continue # skip unknown
                 result.append({
                     'lon': str(feature['geometry']['coordinates'][0]),
                     'lat': str(feature['geometry']['coordinates'][1]),
                     'display_name': feature['properties']['label'],
                 })
                 break
     class SearchPathView(GenericEndpointView):
         def get_connector(self, **kwargs):
             return 'base_adresse'
             return utils.response_for_json(request, result)
     class SearchPathView(SearchView):
         def get_query(self, request, *args, **kwargs):
             return kwargs.get('path')
     class ReverseView(View, SingleObjectMixin):
         model = BaseAdresse
         def get_params(self, request, *args, **kwargs):
             params = super(SearchPathView, self).get_params(request, *args, **kwargs)
             params['q'] = kwargs.pop('path')
             return params
         def get(self, request, *args, **kwargs):
             response_format = 'json'
             if 'format' in request.GET:
                 response_format = request.GET['format']
             if response_format != 'json':
                 raise NotImplementedError()
             if not 'lat' in request.GET or not 'lon' in request.GET:
                 return HttpResponseBadRequest('missing parameter')
             lat = request.GET['lat']
             lon = request.GET['lon']
             scheme, netloc, path, params, query, fragment = urlparse.urlparse(
                     self.get_object().service_url)
             path = '/reverse/'
             query = urllib.urlencode({'lat': lat, 'lon': lon})
             url = urlparse.urlunparse((scheme, netloc, path, params, query, fragment))
             result_response = requests.get(url)
             result = None
             for feature in result_response.json().get('features'):
                 if not feature['geometry']['type'] == 'Point':
                     continue # skip unknown
                 result = {}
                 result['lon'] = str(feature['geometry']['coordinates'][0])
                 result['lat'] = str(feature['geometry']['coordinates'][1])
                 result['address'] = {'country': 'France'}
                 for prop in feature['properties']:
                     if prop in ('city', 'postcode'):
                         result['address'][prop] = feature['properties'][prop]
                     elif prop == 'housenumber':
                         result['address']['house_number'] = feature['properties'][prop]
                     elif prop == 'label':
                         result['display_name'] = feature['properties'][prop]
                     elif prop == 'name':
                         house_number = feature['properties'].get('housenumber')
                         value = feature['properties'][prop]
                         if house_number and value.startswith(house_number):
                             value = value[len(house_number):].strip()
                         result['address']['road'] = value
             return utils.response_for_json(request, result)
             kwargs['endpoint'] = 'search'
             return super(SearchPathView, self).get(request, *args, **kwargs)

     from .views import (HomePageView, ManageView, ManageAddView,
             GenericCreateConnectorView, GenericDeleteConnectorView,
             GenericEditConnectorView,
             GenericEditConnectorView, GenericEndpointView,
             LEGACY_APPS_PATTERNS, LegacyPageView, login, logout)
     from .urls_utils import decorated_includes, required, app_enabled
     from .base.urls import access_urlpatterns
-...
+            )
     urlpatterns += patterns('',
         url(r'^(?P<connector>[\w,-]+)/(?P<slug>[\w,-]+)/(?P<endpoint>[\w,-]+)$',
             GenericEndpointView.as_view())
+    )
     urlpatterns += patterns('',
         url(r'^manage/(?P<connector>[\w,-]+)/', decorated_includes(login_required,
             include(patterns('',
                 url(r'^add$',

     from django.apps import apps
     from django.contrib.auth import logout as auth_logout
     from django.contrib.auth import views as auth_views
     from django.http import HttpResponseRedirect, Http404
     from django.views.generic import TemplateView, CreateView, DeleteView, UpdateView
     from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseRedirect, Http404
     from django.views.generic import View, TemplateView, CreateView, DeleteView, UpdateView
     from django.views.generic.detail import SingleObjectMixin
     from django.conf import settings
     from django.db import models
     from django.shortcuts import resolve_url
-...
     from passerelle.base.models import BaseResource
     from .utils import response_for_json
     from .forms import GenericConnectorForm
-...
     class GenericConnectorMixin(object):
         def get_connector(self, **kwargs):
             return kwargs.get('connector')
         def dispatch(self, request, *args, **kwargs):
             connector = kwargs.get('connector')
             connector = self.get_connector(**kwargs)
             try:
                 app = apps.get_app_config(connector.replace('-', '_'))
             except LookupError:
-...
             return reverse('manage-home')
     class GenericEndpointView(GenericConnectorMixin, SingleObjectMixin, View):
         def get_params(self, request, *args, **kwargs):
             return dict([(x, request.GET[x]) for x in request.GET.keys()])
         def get(self, request, *args, **kwargs):
             endpoint = getattr(self.get_object(), kwargs.get('endpoint'), None)
             endpoint_info = getattr(endpoint, 'endpoint_info', None)
             if endpoint_info is None:
                 raise Http404()
             try:
                 result = endpoint(request, **self.get_params(request, *args, **kwargs))
             except TypeError as e:
                 return HttpResponseBadRequest(unicode(e))
             return response_for_json(request, result)
     # legacy
     LEGACY_APPS_PATTERNS = {
         'datasources': {'url': 'data', 'name': 'Data Sources'},
+    -

Projet

Général

Profil

Produits Entr'ouvert » Passerelle

0001-general-add-generic-endpoint-view-11204.patch