Produits Entr'ouvert » Combo

# -*- coding: utf-8 -*-

from __future__ import unicode_literals

from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [

        ('data', '0027_page_picture'),

        ('auth', '0006_require_contenttypes_0002'),

        ('maps', '0001_initial'),

    ]

    operations = [

        migrations.CreateModel(

            name='Map',

            fields=[

                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),

                ('placeholder', models.CharField(max_length=20)),

                ('order', models.PositiveIntegerField()),

                ('slug', models.SlugField(verbose_name='Slug', blank=True)),

                ('extra_css_class', models.CharField(max_length=100, verbose_name='Extra classes for CSS styling', blank=True)),

                ('public', models.BooleanField(default=True, verbose_name='Public')),

                ('restricted_to_unlogged', models.BooleanField(default=False, verbose_name='Restrict to unlogged users')),

                ('last_update_timestamp', models.DateTimeField(auto_now=True)),

                ('title', models.CharField(max_length=150, verbose_name='Title', blank=True)),

                ('default_position', models.CharField(default=b'48.83369263315934;2.3233688436448574', max_length=128, null=True, verbose_name='Default position', blank=True)),

                ('initial_zoom', models.CharField(default=b'13', max_length=2, verbose_name='Initial zoom level', choices=[(b'0', 'Whole world'), (b'9', 'Wide area'), (b'11', 'Area'), (b'13', 'Town'), (b'16', 'Small road'), (b'19', 'Ant')])),

                ('min_zoom', models.CharField(default=b'0', max_length=2, verbose_name='Minimal zoom level', choices=[(b'0', 'Whole world'), (b'9', 'Wide area'), (b'11', 'Area'), (b'13', 'Town'), (b'16', 'Small road'), (b'19', 'Ant')])),

                ('max_zoom', models.CharField(default=19, max_length=2, verbose_name='Maximal zoom level', choices=[(b'0', 'Whole world'), (b'9', 'Wide area'), (b'11', 'Area'), (b'13', 'Town'), (b'16', 'Small road'), (b'19', 'Ant')])),

                ('groups', models.ManyToManyField(to='auth.Group', verbose_name='Groups', blank=True)),

                ('layers', models.ManyToManyField(to='maps.MapLayer', verbose_name='Layers', blank=True)),

                ('page', models.ForeignKey(to='data.Page')),

            ],

            options={

                'verbose_name': 'Map Cell',

            },

        ),

    ]

from django.core.urlresolvers import reverse_lazy

from django import forms

from django import template

from django.conf import settings

from django.core.exceptions import PermissionDenied

from combo.data.models import CellBase

from combo.data.library import register_cell_class

zoom_levels = [ ('0', _('Whole world')),

                ('9', _('Wide area')),

                ('11', _('Area')),

                ('13', _('Town')),

                ('16', _('Small road')),

                ('19', _('Ant')),]

class MapWidget(forms.TextInput):

    template_name = 'maps/map_widget.html'

    def render(self, name, value, attrs):

        final_attrs = self.build_attrs(attrs, name=name, value=value,

                                       type='hidden')

        cell_form_template = template.loader.get_template(self.template_name)

        return cell_form_template.render(final_attrs)

    def get_geojson(self, request):

                            user=request.user,

            if 'display_fields' not in feature['properties']:

                display_fields = []

                for label, value in feature['properties'].iteritems():

                    if value is not None:

                        display_fields.append((label, value))

                feature['properties']['display_fields'] = display_fields

@register_cell_class

class Map(CellBase):

    title = models.CharField(_('Title'), max_length=150, blank=True)

    default_position = models.CharField(_('Default position'), null=True, blank=True,

                            default='%(lat)s;%(lon)s' % settings.COMBO_MAP_DEFAULT_POSITION,

                            max_length=128)

    initial_zoom = models.CharField(_('Initial zoom level'), max_length=2,

                                    choices=zoom_levels, default='13')

    min_zoom = models.CharField(_('Minimal zoom level'), max_length=2,

                                   choices=zoom_levels, default='0')

    max_zoom = models.CharField(_('Maximal zoom level'), max_length=2,

                                choices=zoom_levels, default=19)

    layers = models.ManyToManyField(MapLayer, verbose_name=_('Layers'), blank=True)

    template_name = 'maps/map_cell.html'

    class Meta:

        verbose_name = _('Map')

    class Media:

        js = ('xstatic/leaflet.js', 'js/combo.map.js')

        css = {'all': ('xstatic/leaflet.css', 'xstatic/css/font-awesome.min.css',

                       'css/combo.map.css')}

    def get_default_form_class(self):

        fields = ('title', 'default_position', 'initial_zoom', 'min_zoom',

                  'max_zoom', 'layers')

        lat, lng = self.default_position.split(';')

        widgets = {'layers': forms.widgets.CheckboxSelectMultiple,

                   'default_position': MapWidget(attrs={'init_lat': lat,

                                                        'init_lng': lng,

                                                        'init_zoom': self.initial_zoom,

                                                        'min_zoom': self.min_zoom,

                                                        'max_zoom': self.max_zoom,

                                                        'tile_urltemplate': settings.COMBO_MAP_TILE_URLTEMPLATE,

                                                        'map_attribution': settings.COMBO_MAP_ATTRIBUTION})}

        return forms.models.modelform_factory(self.__class__, fields=fields,

                                             widgets=widgets)

    def get_geojson(self, request):

        geojson = {'type': 'FeatureCollection', 'features': []}

        if not self.page.is_visible(request.user):

            raise PermissionDenied()

        if not self.is_visible(request.user):

            raise PermissionDenied()

        for layer in self.layers.all():

            geojson['features'] += layer.get_geojson(request)

        return geojson

    @classmethod

    def is_enabled(cls):

        return MapLayer.objects.count() > 0

    def get_cell_extra_context(self, context):

        ctx = super(Map, self).get_cell_extra_context(context)

        ctx['title'] = self.title

        ctx['initial_lat'], ctx['initial_lng'] = self.default_position.split(';');

        ctx['initial_zoom'] = self.initial_zoom

        ctx['min_zoom'] = self.min_zoom

        ctx['max_zoom'] = self.max_zoom

        ctx['geojson_url'] = reverse_lazy('mapcell-geojson', kwargs={'cell_id': self.pk})

        ctx['tile_urltemplate'] = settings.COMBO_MAP_TILE_URLTEMPLATE

        ctx['map_attribution'] = settings.COMBO_MAP_ATTRIBUTION

        return ctx

div.combo-cell-map {

    height: 60vh;

}

/* leaflet styles */

div.leaflet-div-icon span {

    width: 2.3rem;

    height: 2.3rem;

    display: block;

    left: -1rem;

    top: -1rem;

    position: relative;

    border-radius: 11rem 6rem 0.8rem;

    transform: scale(1, 1.3) rotate(45deg);

    border: 1px solid #aaa;

}

div.leaflet-popup-content span {

    display: block;

}

div.leaflet-popup-content span.field-label {

    text-transform: capitalize;

}

div.leaflet-popup-content span.field-value {

    font-weight: bold;

}

div.leaflet-div-icon span i:before {

    display: inline-block;

    margin: 9px;

    transform: scale(1.1) rotate(-45deg);

}

$(function() {

    function render_map() {

        $('div.combo-cell-map').each(function() {

            var $map_widget = $(this);

            var map_options = Object();

            var initial_zoom = parseInt($map_widget.data('init-zoom'));

            if (! isNaN(initial_zoom)) {

                map_options.zoom = initial_zoom;

            } else {

                map_options.zoom = 13;

            }

            var max_zoom = parseInt($map_widget.data('max_zoom'));

            if (!isNaN(max_zoom)) map_options.maxZoom = max_zoom;

            var min_zoom = parseInt($map_widget.data('min-zoom'));

            if (!isNaN(min_zoom)) map_options.minZoom = min_zoom;

            var latlng = [$map_widget.data('init-lat'), $map_widget.data('init-lng')];

            var geojson_url = $map_widget.data('geojson-url');

            var map_tile_url = $map_widget.data('tile-urltemplate');

            var map_attribution = $map_widget.data('map-attribution');

            var map = L.map(this, map_options);

            var store_position_selector = $map_widget.data('store-position');

            map.setView(latlng, map_options.zoom);

            L.tileLayer(map_tile_url,

                {

                    attribution: map_attribution

                }).addTo(map);

            if (store_position_selector) {

                map.marker = L.marker(latlng);

                map.marker.addTo(map);

                var hidden = $('input#' + store_position_selector);

                map.on('click', function(e) {

                    map.marker.setLatLng(e.latlng);

                    hidden.val(e.latlng.lat + ';' + e.latlng.lng);

                });

            }

            if (geojson_url) {

                $.getJSON(geojson_url, function(data) {

                    var geo_json = L.geoJson(data, {

                        onEachFeature: function(feature, layer) {

                            if (feature.properties.display_fields) {

                                var popup = '';

                                $.each(feature.properties.display_fields, function(key, value) {

                                    popup += '<p class="popup-field"><span class="field-label">' + value[0] + '</span>';

                                    popup += '<span class="field-value">' + value[1] + '</span></p>';

                                });

                            } else {

                                var popup = '<p class="popup-field">' + feature.properties.label + '</p>';

                            }

                            layer.bindPopup(popup);

                        },

                        pointToLayer: function (feature, latlng) {

                            var markerStyles = "background-color: "+feature.properties.colour+";";

                            marker = L.divIcon({iconAnchor: [0, 30],

                                                popupAnchor: [5, -45],

                                                html: '<span style="' + markerStyles + '"><i class="fa '+feature.properties.icon+'" style="color:'+feature.properties.icon_colour+'"></i></span>'

                                               });

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

                        }

                    });

                    map.fitBounds(geo_json.getBounds());

                    geo_json.addTo(map);

                });

            }

        });

    }

    $('div.combo-cell-map').parents('div.cell').on('combo:cellform-reloaded', function() {

        render_map();

    });

    $('div.combo-cell-map').parents('div.cell').trigger('combo:cellform-reloaded');

});

<h2>{{ title }}</h2>

<div class="combo-cell-map" data-init-zoom="{{ initial_zoom }}" data-min-zoom="{{ min_zoom }}" data-max-zoom="{{ max_zoom }}" data-init-lat="{{ initial_lat }}" data-init-lng="{{ initial_lng }}" data-geojson-url="{{ geojson_url }}" data-tile-urltemplate="{{ tile_urltemplate}}" data-map-attribution="{{ map_attribution}}">

</div>

<div class="combo-cell-map" data-init-zoom="{{ init_zoom }}" data-min-zoom="{{ min_zoom }}" data-max-zoom="{{ max_zoom }}" data-init-lat="{{ init_lat }}" data-init-lng="{{ init_lng }}" data-store-position="combo-map-{{ id }}" data-tile-urltemplate="{{ tile_urltemplate}}" data-map-attribution="{{ map_attribution}}">

</div>

<input type="{{ type }}" name="{{ name }}" value="{{ value }}" id="combo-map-{{ id }}" />

from .views import GeojsonView

    url(r'^ajax/mapcell/geojson/(?P<cell_id>\w+)/$', GeojsonView.as_view(),

        name='mapcell-geojson'),

# combo - content management system

# Copyright (C) 2017  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import json

from django.views.generic.base import View

from django.http import HttpResponse, Http404

from .models import Map

class GeojsonView(View):

    def get(self, request, *args, **kwargs):

        try:

            cell = Map.objects.get(pk=kwargs['cell_id'])

        except Map.DoesNotExist:

            raise Http404()

        geojson = cell.get_geojson(request)

        content_type = 'application/json'

        return HttpResponse(json.dumps(geojson), content_type=content_type)

<link rel="stylesheet" type="text/css" media="all" href="{% static "xstatic/leaflet.css" %}"></script>

<link rel="stylesheet" type="text/css" media="all" href="{% static "css/combo.map.css" %}"></script>

<script src="{% static "xstatic/leaflet.js" %}"></script>

<script src="{% static "js/combo.map.js" %}"></script>

    'xstatic.pkg.leaflet',

# default position on maps

COMBO_MAP_DEFAULT_POSITION = {'lat': '48.83369263315934',

                              'lon': '2.3233688436448574'

                              }

# default map tiles url

COMBO_MAP_TILE_URLTEMPLATE = 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png'

# default combo map attribution

COMBO_MAP_ATTRIBUTION = 'Map data &copy; <a href="https://openstreetmap.org">OpenStreetMap</a> contributors, <a href="http://creativecommons.org/licenses/by-sa/2.0/">CC-BY-SA</a>'

    python-xstatic-leaflet,

XStatic-Leaflet

        'XStatic-Leaflet',

# -*- coding: utf-8 -*-

import pytest

from django.contrib.auth.models import User

from django.test.client import RequestFactory

from django.template import Context

from django.test import Client

from django.core.urlresolvers import reverse

from django.contrib.auth.models import Group

from combo.data.models import Page

from combo.apps.maps.models import MapLayer, Map

pytestmark = pytest.mark.django_db

client = Client()

@pytest.fixture

def user():

    try:

        user = User.objects.get(username='admin')

    except User.DoesNotExist:

        user = User.objects.create_user('admin', email=None, password='admin')

    return user

@pytest.fixture

def layer():

    try:

        layer = MapLayer.objects.get()

    except MapLayer.DoesNotExist:

        layer = MapLayer()

        layer.geojson_url = 'http://example.net/geojson'

        layer.marker_colour = 'FF0000'

        layer.icon = 'fa-bicycle'

        layer.icon_colour = '0000FF'

        layer.save()

    return layer

def login(username='admin', password='admin'):

    resp = client.post('/login/', {'username': username, 'password': password})

    assert resp.status_code == 302

def test_cell_disabled():

    MapLayer.objects.all().delete()

    assert Map.is_enabled() is False

def test_cell_enabled(layer):

    assert Map.is_enabled() is True

def test_cell_rendering(layer):

    page = Page(title='xxx', slug='test_map_cell', template_name='standard')

    page.save()

    cell = Map(page=page, placeholder='content', order=0,

                   title = 'Map with points')

    cell.save()

    cell.layers.add(layer)

    context = Context({'request': RequestFactory().get('/')})

    rendered = cell.render(context)

    assert 'data-init-zoom="13"' in rendered

    assert 'data-min-zoom="0"' in rendered

    assert 'data-max-zoom="19"' in rendered

    assert 'data-init-lat="48.83369263315934"' in rendered

    assert 'data-init-lng="2.3233688436448574"' in rendered

    assert 'data-geojson-url="/ajax/mapcell/geojson/1/"' in rendered

    resp = client.get('/test_map_cell/')

    assert 'xstatic/leaflet.js' in resp.content

    assert 'js/combo.map.js' in resp.content

    assert 'xstatic/leaflet.css' in resp.content

    assert 'xstatic/css/font-awesome.min.css' in resp.content

    assert 'css/combo.map.css' in resp.content

def test_get_geojson_on_non_public_page(layer):

    page = Page(title='xxx', slug='new', template_name='standard',

                public=False)

    page.save()

    cell = Map(page=page, placeholder='content', order=0,

                   title = 'Map with points')

    cell.save()

    cell.layers.add(layer)

    resp = client.get(reverse('mapcell-geojson', kwargs={'cell_id': cell.id}))

    assert resp.status_code == 403

def test_get_geojson_on_non_publik_cell(layer):

    page = Page(title='xxx', slug='new', template_name='standard')

    page.save()

    cell = Map(page=page, placeholder='content', order=0, public=False,

                   title = 'Map with points')

    cell.save()

    cell.layers.add(layer)

    resp = client.get(reverse('mapcell-geojson', kwargs={'cell_id': cell.id}))

    assert resp.status_code == 403

def test_geojson_on_restricted_cell(layer, user):

    page = Page(title='xxx', slug='new', template_name='standard')

    page.save()

    group = Group.objects.create(name='map tester')

    cell = Map(page=page, placeholder='content', order=0, public=False)

    cell.title = 'Map with points'

    cell.save()

    cell.layers.add(layer)

    cell.groups.add(group)

    login()

    resp = client.get(reverse('mapcell-geojson', kwargs={'cell_id': cell.id}))

    assert resp.status_code == 403

        assert item['properties']['display_fields'] == [('property', 'property value')]

                        'properties': {'property': 'a random value',

                                       'display_fields': [('foo', 'bar')]}}

        assert item['properties']['display_fields'] == [('foo', 'bar')]