Produits Entr'ouvert » w.c.s.

from webtest import Upload, Hidden, Radio

    assert data.data == {'0': {'lat': 1.234, 'lon': -1.234}, '0_display': '1.234;-1.234', '1': 'bla'}

    assert data.data == {'1': {'lat': 1.234, 'lon': -1.234}, '1_display': '1.234;-1.234', '3': 'bar'}

def test_form_map_data_source(pub, http_requests):

    NamedDataSource.wipe()

    data_source = NamedDataSource(name='foobar')

    data_source.data_source = {

        'type': 'geojson',

        'value': 'http://remote.example.net/geojson',

    }

    data_source.id_property = 'id'

    data_source.label_template_property = '{{ text }}'

    data_source.store()

    formdef = create_formdef()

    formdef.fields = [

        fields.MapField(id='1', label='map', data_source={'type': 'foobar'}),

    ]

    formdef.store()

    formdef.data_class().wipe()

    resp = get_app(pub).get('/test/')

    assert resp.pyquery('div[data-markers-radio-name]')[0].attrib['data-markers-url'] == '/api/geojson/foobar'

    assert resp.pyquery('div[data-markers-radio-name]')[0].attrib['data-markers-radio-name'] == 'f1$marker_id'

    # simulate qommon.map.js that will create radio inputs

    resp.form.fields['f1$marker_id'] = [Radio(form=resp.form, tag='input', name='f1$marker_id', pos=5)]

    resp.form.fields['f1$marker_id'][0].options.append(('1', False, None))

    resp.form.fields['f1$marker_id'][0].options.append(('2', False, None))

    resp.form.fields['f1$marker_id'][0].optionPositions.append(5)

    resp.form.fields['f1$marker_id'][0].optionPositions.append(6)

    resp.form.field_order.append(('f1$marker_id', resp.form.fields['f1$marker_id'][0]))

    resp.form['f1$marker_id'].value = '1'  # click on marker

    resp.form['f1$latlng'] = '1;2'  # set via js

    resp = resp.form.submit('submit')

    assert 'Check values then click submit.' in resp

    # selected option is displayed as readonly:

    assert resp.pyquery('input[type=text][value=foo][readonly]')

    assert resp.pyquery('input[type=hidden][name="f1$marker_id"][value="1"]')

    assert int(float(resp.pyquery('.qommon-map')[0].attrib['data-init-lat'])) == 1

    assert int(float(resp.pyquery('.qommon-map')[0].attrib['data-init-lng'])) == 2

    resp = resp.form.submit('submit')

    resp = resp.follow()

    assert 'The form has been recorded' in resp

    assert resp.pyquery('input[type=text][value=foo][readonly]')

    assert int(float(resp.pyquery('.qommon-map')[0].attrib['data-init-lat'])) == 1

    assert int(float(resp.pyquery('.qommon-map')[0].attrib['data-init-lng'])) == 2

    assert formdef.data_class().count() == 1

    data_id = formdef.data_class().select()[0].id

    data = formdef.data_class().get(data_id)

    assert data.data == {'1': {'lat': 1.0, 'lon': 2.0, 'marker_id': '1'}, '1_display': 'foo'}

from wcs.data_sources import NamedDataSource

    formdata.data['7_display'] = formdef.fields[7].store_display_value(formdata.data, '7')

def test_lazy_formdata_map_item_field(pub, http_requests):

    NamedDataSource.wipe()

    data_source = NamedDataSource(name='foobar')

    data_source.data_source = {

        'type': 'geojson',

        'value': 'http://remote.example.net/geojson',

    }

    data_source.id_property = 'id'

    data_source.label_template_property = '{{ text }}'

    data_source.store()

    FormDef.wipe()

    formdef = FormDef()

    formdef.name = 'foobar map item'

    formdef.fields = [

        fields.MapField(id='14', label='map-item', varname='map_item', data_source={'type': 'foobar'}),

    ]

    formdef.store()

    formdef.data_class().wipe()

    formdata = formdef.data_class()()

    formdata.just_created()

    formdata.data = {

        '14': {'lat': 1, 'lon': 2, 'marker_id': '1'},  # map-item

    }

    formdata.data['14_display'] = formdef.fields[0].store_display_value(formdata.data, '14')

    formdata.store()

    pub.substitutions.feed(pub)

    pub.substitutions.feed(formdef)

    pub.substitutions.feed(formdata)

    context = pub.substitutions.get_context_variables(mode='lazy')

    assert Template('{{form_var_map_item}}').render(context) == 'foo'

    assert Template('{{form_var_map_item_lat}}').render(context) == '1'

    assert Template('{{form_var_map_item_lon}}').render(context) == '2'

    assert Template('{{form_var_map_item_marker_id}}').render(context) == '1'

    formdata.data['7_display'] = None

    formdata.data['2_display'] = formdef.fields[0].store_display_value(formdata.data, '2')

    formdata.data['2_display'] = formdef.fields[0].store_display_value(formdata.data, '2')

    formdata.data['2_display'] = formdef.fields[0].store_display_value(formdata.data, '2')

    formdata.data['2_display'] = formdef.fields[0].store_display_value(formdata.data, '2')

import json

        geojson = {

            'features': [

                {'properties': {'id': '1', 'text': 'foo'},

                 'geometry': {'type': 'Point', 'coordinates': [1, 2]}

                },

                {'properties': {'id': '2', 'text': 'bar'},

                 'geometry': {'type': 'Point', 'coordinates': [3, 4]}

                }

            ]

        }

            'http://remote.example.net/geojson': (200, json.dumps(geojson), None),

from wcs.data_sources import get_object as get_data_source_object

class GeoJsonDirectory(Directory):

    def _q_lookup(self, component):

        try:

            data_source = get_data_source_object({'type': component})

        except KeyError:

            raise TraversalError()

        get_response().set_content_type('application/json')

        return json.dumps(data_source.get_geojson_data())

            'cards', 'geojson']

    geojson = GeoJsonDirectory()

            allow_geojson=False, allow_named_sources=True,

            require_configured_geographic_source=False, **kwargs):

            selected_sources = NamedDataSource.select()

            if require_configured_geographic_source:

                selected_sources = [x for x in selected_sources if x.type == 'geojson']

            options.extend([(x.slug, x.name, x.slug) for x in selected_sources])

            if not require_configured_geographic_source:

                from wcs.carddef import CardDef

                options.extend(list(CardDef.get_as_data_source_options()))

        if not require_configured_geographic_source:

            options.append(('json', _('JSON URL'), 'json'))

            if allow_jsonp:

                options.append(('jsonp', _('JSONP URL'), 'jsonp'))

            if allow_geojson:

                options.append(('geojson', _('GeoJSON URL'), 'geojson'))

            options.append(('formula', _('Python Expression'), 'python'))

def get_json_from_url(url, data_source):

    return entries

def request_json_items(url, data_source):

    geojson = data_source.get('type') == 'geojson'

    entries = get_json_from_url(url, data_source)

    if entries is None:

        return None

    def get_geojson_url(self):

        assert self.type == 'geojson'

        return '/api/geojson/%s' % self.slug

    def get_geojson_data(self):

        url = self.data_source.get('value').strip()

        if Template.is_template_string(url):

            vars = get_publisher().substitutions.get_context_variables(mode='lazy')

            url = get_variadic_url(url, vars)

        request = get_request()

        if hasattr(request, 'datasources_cache') and url in request.datasources_cache:

            return request.datasources_cache[url]

        cache_duration = 0

        if self.cache_duration:

            cache_duration = int(self.cache_duration)

        if cache_duration:

            cache_key = 'geojson-data-source-%s' % force_str(hashlib.md5(force_bytes(url)).hexdigest())

            from django.core.cache import cache

            data = cache.get(cache_key)

            if data is not None:

                return data

        data = get_json_from_url(url, self.data_source)

        id_property = self.id_property or 'id'

        label_template_property = self.label_template_property or '{{ text }}'

        for feature in data['features']:

            feature['properties']['_id'] = feature['properties'][id_property]

            try:

                feature['properties']['_text'] = Template(

                        label_template_property).render(feature['properties'])

            except (TemplateSyntaxError, VariableDoesNotExist):

                pass

            if not feature['properties'].get('_text'):

                feature['properties']['_text'] = feature['properties']['_id']

        if hasattr(request, 'datasources_cache'):

            request.datasources_cache[url] = data

        if cache_duration:

            cache.set(cache_key, data, cache_duration)

        return data

            structured_items = get_structured_items(self.extended_data_source, mode='lazy')

    def add_to_view_form(self, form, value=None, display_value=None, **kwargs):

        widget_kwargs = {'render_br': False}

        self.perform_more_widget_changes(form, widget_kwargs, False)

                widget_kwargs[k] = getattr(self, k)

        if self.widget_class is StringWidget and not 'size' in widget_kwargs and value:

            widget_kwargs['size'] = len(value)

        if display_value and getattr(self.widget_class, 'allow_display_value', True):

            widget_kwargs['display_value'] = display_value

        form.add(self.widget_class, self.field_key, title=self.label,

                value=value, readonly='readonly', **widget_kwargs)

        return widget

    def add_to_view_form(self, form, value=None, **kwargs):

        return super().add_to_view_form(form, value=value, **kwargs)

    def add_to_view_form(self, form, value=None, **kwargs):

    data_source = {}

        form.add(data_sources.DataSourceSelectionWidget, 'data_source',

                 value=self.data_source,

                 title=_('Markers data source'),

                 hint=_('This will fill the map with markers from an external source.'),

                 required=False,

                 require_configured_geographic_source=True,

                 advanced=False)

                'init_with_geoloc', 'data_source']

    def add_to_view_form(self, form, value=None, **kwargs):

        widget = super().add_to_view_form(form, value=value, **kwargs)

        if self.data_source:

            data_source = data_sources.get_object(self.data_source)

            widget.add_geojson_markers(data_source.get_geojson_url())

        return widget

    def add_to_form(self, form, value=None):

        widget = super().add_to_form(form, value=value)

        if self.data_source:

            data_source = data_sources.get_object(self.data_source)

            widget.add_geojson_markers(data_source.get_geojson_url())

        return widget

        widget_kwargs = {}

        if 'value_id' in kwargs:  # get raw value

            widget_kwargs['display_value'] = value

            value = kwargs.get('value_id')

        widget = self.widget_class('x%s' % random.random(), value, readonly=True, **widget_kwargs)

    def get_view_short_value(self, value, max_len=30, raw_value=None, **kwargs):

        if self.data_source:

            # value will be _display value

            return value or ''

        return self.get_view_value(value, value_id=raw_value)

    def get_display_value(self, value):

        if not self.data_source:

            if value:

                # backward compatibility

                return '%(lat)s;%(lon)s' % value

            return ''

        data_source = data_sources.get_object(self.data_source)

        if data_source is None or value is None:

            return ''

        return data_source.get_display_value(value.get('marker_id'))

    def store_display_value(self, data, field_id):

        value = data.get(field_id)

        return self.get_display_value(value)

            display_value = self.data.get('%s_display' % field.id, field_value)

            return field.get_view_short_value(display_value, max_length, raw_value=field_value)

            if (value is None and not value_details) and not (f.required and include_unset_required_fields):

                    kwargs = {}

                    if field.store_display_value:

                        kwargs['display_value'] = dict.get(field.id + '_display')

                    field.add_to_view_form(form, value, **kwargs)

            if value is None and not value_details:

    geojson_markers_url = None

        self.display_value = kwargs.pop('display_value', None)

    def add_geojson_markers(self, url):

        self.geojson_markers_url = url

        self.add(HiddenWidget, 'marker_id')

            if self.geojson_markers_url:

                self.value['marker_id'] = self.get('marker_id')

     var initial_marker_id = $map_widget.data('markers-initial-id');

       if (typeof initial_marker_id == 'undefined') {

         // if markers are used they will appear via their input widget

         map.marker = L.marker(latlng);

         map.marker.addTo(map);

       }

     if ($map_widget.data('markers-url')) {

       var radio_name = $map_widget.data('markers-radio-name');

       $map_widget.on('change', 'input[name="' + radio_name + '"]', function() {

         var $radio = $(this);

         if ($radio.is(':checked')) {

           hidden.val($radio.data('lat') + ';' + $radio.data('lng'));

           hidden.trigger('change');

         }

       });

       $.getJSON($map_widget.data('markers-url')).done(

         function(data) {

           var geo_json = L.geoJson(data, {

             pointToLayer: function (feature, latlng) {

               var $label = $('<label>', {

                 title: feature.properties._text

               });

               var $radio = $('<input>', {

                 value: feature.properties._id,

                 name: radio_name,

                 type: 'radio',

                 'data-lat': latlng.lat,

                 'data-lng': latlng.lng

               });

               if (typeof initial_marker_id !== 'undefined' && feature.properties._id == initial_marker_id) {

                 $radio.attr('checked', 'checked');

               }

               $label.append($radio);

               $label.append($('<span></span>'));

               var div_marker = L.divIcon({

                 className: 'item-marker',

                 html: '<div>' + $label.prop('outerHTML') + '</div>'

               });

               return L.marker(latlng, {icon: div_marker});

             }

           });

           geo_json.addTo(map);

         }

       );

     } else if ($map_widget.data('readonly') && initial_marker_id) {

       // readonly and marker

       console.log('plop');

         map.marker = L.marker(latlng);

         map.marker.addTo(map);

     }

     if (! $map_widget.data('readonly') && ! $map_widget.data('markers-url')) {

{% if widget.display_value and widget.readonly %}

<div class="display-value"><input type="text"

  value="{{widget.display_value}}" readonly size="{{widget.display_value|length}}"></div>

{% endif %}

  {% if widget.geojson_markers_url %}

    {% if not widget.readonly %}

    data-markers-url="{{ widget.geojson_markers_url }}"

    data-markers-radio-name="{{widget.name}}$marker_id"

    {% endif %}

    {% if widget.value.marker_id %}

    data-markers-initial-id="{{ widget.value.marker_id }}"

    {% endif %}

  {% endif %}

{% if widget.readonly and widget.geojson_markers_url and widget.value.marker_id %}

<input type="hidden" name="{{widget.name}}$marker_id" value="{{ widget.value.marker_id }}">

{% endif %}

{% if widget.geojson_markers_url %}

<style>

.item-marker input + span {

  position: relative;

  z-index: 1000;

  margin-top: -55px;

  margin-left: -5px;

  display: block;

  width: 25px;

  height: 41px;

  background: url(/static/images/blank-marker-icon.png);

}

.item-marker input:checked + span {

  background: url(/static/xstatic/images/marker-icon.png);

}

.MapWidget div.display-value {

  max-width: 100%;

}

</style>

{% endif %}

        if self._field.data_source:

            return ['lat', 'lon', 'marker_id']

    @property

    def marker_id(self):

        value = self._data.get(self._field.id)

        if value:

            return value.get('marker_id')

        if self._field.data_source:

            value = self._data.get(self._field.id + '_display')

            if value:

                return value

        # "lat;lon" for backward compatibility