Switch to PSR-4.

src/Mapper/Layer/AbstractLayerMapper.php

@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * @package    contao-leaflet-maps
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014-2016 netzmacht David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper\Layer;
+
+use Netzmacht\Contao\Leaflet\Mapper\AbstractTypeMapper;
+
+/**
+ * Class AbstractLayerMapper is the base mapper for the layer model.
+ *
+ * @package Netzmacht\Contao\Leaflet\Mapper\Layer
+ */
+class AbstractLayerMapper extends AbstractTypeMapper
+{
+    /**
+     * Class of the model being build.
+     *
+     * @var string
+     */
+    protected static $modelClass = 'Netzmacht\Contao\Leaflet\Model\LayerModel';
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function initialize()
+    {
+        parent::initialize();
+
+        $this->optionsBuilder->addOption('label', 'title');
+    }
+}

src/Mapper/Layer/GroupLayerMapper.php

@@ -0,0 +1,77 @@
+<?php
+
+/**
+ * @package    contao-leaflet-maps
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014-2016 netzmacht David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper\Layer;
+
+use Netzmacht\Contao\Leaflet\Filter\Filter;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\Contao\Leaflet\Model\LayerModel;
+use Netzmacht\LeafletPHP\Definition;
+use Netzmacht\LeafletPHP\Definition\Group\LayerGroup;
+use Netzmacht\LeafletPHP\Definition\Layer;
+
+/**
+ * Class GroupLayerMapper maps the layer model to the group layer definition.
+ *
+ * @package Netzmacht\Contao\Leaflet\Mapper\Layer
+ */
+class GroupLayerMapper extends AbstractLayerMapper
+{
+    /**
+     * Layer type.
+     *
+     * @var string
+     */
+    protected static $type = 'group';
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getClassName(\Model $model, DefinitionMapper $mapper, Filter $filter = null)
+    {
+        if ($model->groupType === 'feature') {
+            return 'Netzmacht\LeafletPHP\Definition\Group\FeatureGroup';
+        }
+
+        return 'Netzmacht\LeafletPHP\Definition\Group\LayerGroup';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function build(
+        Definition $definition,
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        Definition $parent = null
+    ) {
+        if (!$definition instanceof LayerGroup) {
+            return;
+        }
+
+        $collection = LayerModel::findBy(
+            array('pid=?', 'active=1'),
+            array($model->id),
+            array('order' => 'sorting')
+        );
+
+        if ($collection) {
+            foreach ($collection as $layerModel) {
+                $layer = $mapper->handle($layerModel);
+
+                if ($layer instanceof Layer) {
+                    $definition->addLayer($layer);
+                }
+            }
+        }
+    }
+}

src/Mapper/Layer/MarkerClusterLayerMapper.php

@@ -0,0 +1,132 @@
+<?php
+
+/**
+ * @package    contao-leaflet-maps
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014-2016 netzmacht David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper\Layer;
+
+use Netzmacht\Contao\Leaflet\ContaoAssets;
+use Netzmacht\Contao\Leaflet\Filter\Filter;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\Contao\Leaflet\Model\LayerModel;
+use Netzmacht\Contao\Toolkit\View\Assets\AssetsManager;
+use Netzmacht\JavascriptBuilder\Type\AnonymousFunction;
+use Netzmacht\JavascriptBuilder\Type\Expression;
+use Netzmacht\LeafletPHP\Definition;
+use Netzmacht\LeafletPHP\Definition\Layer;
+use Netzmacht\LeafletPHP\Plugins\MarkerCluster\MarkerClusterGroup;
+use Netzmacht\LeafletPHP\Plugins\Omnivore\OmnivoreLayer;
+
+/**
+ * Class MarkerClusterLayerMapper maps the layer database model to the marker cluster definition.
+ *
+ * @package Netzmacht\Contao\Leaflet\Mapper\Layer
+ */
+class MarkerClusterLayerMapper extends AbstractLayerMapper
+{
+    /**
+     * Class of the definition being created.
+     *
+     * @var string
+     */
+    protected static $definitionClass = 'Netzmacht\LeafletPHP\Plugins\MarkerCluster\MarkerClusterGroup';
+
+    /**
+     * Layer type.
+     *
+     * @var string
+     */
+    protected static $type = 'markercluster';
+
+    /**
+     * Assets manager.
+     *
+     * @var ContaoAssets
+     */
+    private $assets;
+
+    /**
+     * MarkerClusterLayerMapper constructor.
+     *
+     * @param ContaoAssets $assets Assets manager.
+     */
+    public function __construct(ContaoAssets $assets)
+    {
+        parent::__construct();
+
+        $this->assets = $assets;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function initialize()
+    {
+        parent::initialize();
+
+        $this->optionsBuilder
+            ->addOptions('showCoverageOnHover', 'zoomToBoundsOnClick', 'spiderfyOnMaxZoom')
+            ->addOption('removeOutsideVisibleBounds')
+            ->addConditionalOption('maxClusterRadius')
+            ->addConditionalOption('singleMarkerMode')
+            ->addConditionalOption('animateAddingMarkers')
+            ->addConditionalOption('disableClusteringAtZoom')
+            ->addConditionalOption('spiderfyDistanceMultiplier');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function build(
+        Definition $definition,
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        Definition $parent = null
+    ) {
+        parent::build($definition, $model, $mapper, $filter, $parent);
+
+        /** @var MarkerClusterGroup $definition */
+
+        if ($model->iconCreateFunction) {
+            $definition->setIconCreateFunction(new Expression($model->iconCreateFunction));
+        }
+
+        if ($model->polygonOptions) {
+            $definition->setPolygonOptions((array) json_decode($model->polygonOptions, true));
+        }
+
+        if (!$model->disableDefaultStyle) {
+            $this->assets->addStylesheet('assets/leaflet/libs/leaflet-markercluster/MarkerCluster.Default.css');
+        }
+
+        $collection = LayerModel::findBy(
+            array('pid=?', 'active=1'),
+            array($model->id),
+            array('order' => 'sorting')
+        );
+
+        if ($collection) {
+            foreach ($collection as $layerModel) {
+                $layer = $mapper->handle($layerModel);
+
+                if ($layer instanceof Layer) {
+                    $definition->addLayer($layer);
+
+                    if ($layer instanceof OmnivoreLayer) {
+                        $callback = new AnonymousFunction();
+                        $callback->addLine('layers.' . $definition->getId() . '.addLayers(this.getLayers())');
+
+                        $layer->on('ready', $callback);
+                    }
+                }
+            }
+        }
+    }
+}

src/Mapper/Layer/MarkersLayerMapper.php

@@ -0,0 +1,160 @@
+<?php
+
+/**
+ * @package    contao-leaflet-maps
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014-2016 netzmacht David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper\Layer;
+
+use Netzmacht\Contao\Leaflet\Filter\Filter;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\Contao\Leaflet\Mapper\GeoJsonMapper;
+use Netzmacht\Contao\Leaflet\Model\MarkerModel;
+use Netzmacht\Contao\Leaflet\Frontend\RequestUrl;
+use Netzmacht\JavascriptBuilder\Type\Expression;
+use Netzmacht\LeafletPHP\Definition;
+use Netzmacht\LeafletPHP\Value\GeoJson\FeatureCollection;
+use Netzmacht\LeafletPHP\Definition\Group\GeoJson;
+
+/**
+ * Class MarkersLayerMapper maps the layer model to the markers definition.
+ *
+ * @package Netzmacht\Contao\Leaflet\Mapper\Layer
+ */
+class MarkersLayerMapper extends AbstractLayerMapper implements GeoJsonMapper
+{
+    /**
+     * Layer type.
+     *
+     * @var string
+     */
+    protected static $type = 'markers';
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getClassName(\Model $model, DefinitionMapper $mapper, Filter $filter = null)
+    {
+        if ($model->deferred) {
+            return 'Netzmacht\LeafletPHP\Plugins\Omnivore\GeoJson';
+        }
+
+        return 'Netzmacht\LeafletPHP\Definition\Group\GeoJson';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function buildConstructArguments(
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        $elementId = null
+    ) {
+        if ($model->deferred) {
+            if ($model->pointToLayer || $model->boundsMode) {
+                $layer = new GeoJson($this->getElementId($model, $elementId));
+
+                if ($model->pointToLayer) {
+                    $layer->setPointToLayer(new Expression($model->pointToLayer));
+                }
+
+                if ($model->boundsMode) {
+                    $layer->setOption('boundsMode', $model->boundsMode);
+                }
+
+                return array(
+                    $this->getElementId($model, $elementId),
+                    RequestUrl::create($model->id, null, null, $filter),
+                    array(),
+                    $layer
+                );
+            }
+
+            return array(
+                $this->getElementId($model, $elementId),
+                RequestUrl::create($model->id, null, null, $filter)
+            );
+        }
+
+        return parent::buildConstructArguments($model, $mapper, $filter, $elementId);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function build(
+        Definition $definition,
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        Definition $parent = null
+    ) {
+        if ($definition instanceof GeoJson) {
+            if ($model->boundsMode) {
+                $definition->setOption('boundsMode', $model->boundsMode);
+            }
+
+            $collection = $this->loadMarkerModels($model);
+
+            if ($collection) {
+                foreach ($collection as $item) {
+                    $marker = $mapper->handle($item);
+                    $point  = $mapper->convertToGeoJsonFeature($marker, $item);
+
+                    if ($point) {
+                        $definition->addData($point, true);
+                    }
+                }
+            }
+
+            if ($model->pointToLayer) {
+                $definition->setPointToLayer(new Expression($model->pointToLayer));
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handleGeoJson(\Model $model, DefinitionMapper $mapper, Filter $filter = null)
+    {
+        $feature    = new FeatureCollection();
+        $collection = $this->loadMarkerModels($model, $filter);
+
+        if ($collection) {
+            foreach ($collection as $item) {
+                $marker = $mapper->handle($item);
+                $point  = $mapper->convertToGeoJsonFeature($marker, $item);
+
+                if ($point) {
+                    $feature->addFeature($point);
+                }
+            }
+        }
+
+        return $feature;
+    }
+
+    /**
+     * Load all layer markers.
+     *
+     * @param \Model $model  The layer model.
+     * @param Filter $filter The request filter.
+     *
+     * @return \Model\Collection|null
+     */
+    protected function loadMarkerModels(\Model $model, Filter $filter = null)
+    {
+        if ($model->boundsMode == 'fit') {
+            return MarkerModel::findByFilter($model->id, $filter);
+        }
+
+        return MarkerModel::findByFilter($model->id);
+    }
+}

src/Mapper/Layer/OverpassLayerMapper.php

@@ -0,0 +1,139 @@
+<?php
+
+/**
+ * @package    netzmacht
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2016 netzmacht David Molineus. All rights reserved.
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper\Layer;
+
+use Model;
+use Netzmacht\Contao\Leaflet\Definition\Layer\OverpassLayer;
+use Netzmacht\Contao\Leaflet\Filter\Filter;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\Contao\Leaflet\Model\IconModel;
+use Netzmacht\JavascriptBuilder\Type\Expression;
+use Netzmacht\LeafletPHP\Definition;
+
+/**
+ * Class OverpassLayerMapper.
+ *
+ * @package Netzmacht\Contao\Leaflet\Mapper\Layer
+ */
+class OverpassLayerMapper extends AbstractLayerMapper
+{
+    /**
+     * The definition type.
+     *
+     * @var string
+     */
+    protected static $type = 'overpass';
+
+    /**
+     * The definition class.
+     *
+     * @var string
+     */
+    protected static $definitionClass = 'Netzmacht\Contao\Leaflet\Definition\Layer\OverpassLayer';
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function initialize()
+    {
+        parent::initialize();
+
+        $this->optionsBuilder
+            ->addOption('query', 'overpassQuery')
+            ->addOption('minZoom')
+            ->addOption('boundsMode')
+            ->addOption('overpassEndpoint', 'endpoint');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function build(
+        Definition $definition,
+        Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        Definition $parent = null
+    ) {
+        if (!$definition instanceof OverpassLayer) {
+            return;
+        }
+
+        $amenityIconsMap = $this->buildAmenityIconsMap($model);
+        $definition->setOption('amenityIcons', $amenityIconsMap);
+
+        if ($model->pointToLayer) {
+            $definition->setPointToLayer(new Expression($model->pointToLayer));
+        }
+
+        if ($model->onEachFeature) {
+            $definition->setOnEachFeature(new Expression($model->onEachFeature));
+        }
+
+        if ($model->overpassPopup) {
+            $definition->setOption('overpassPopup', new Expression($model->overpassPopup));
+        }
+    }
+
+    /**
+     * Build the amenity icons map.
+     *
+     * @param Model $model Definition model.
+     *
+     * @return array
+     */
+    protected function buildAmenityIconsMap(Model $model)
+    {
+        $amenityIconsMap = $this->filterAmenityIconsConfig($model->amenityIcons);
+
+        if ($amenityIconsMap) {
+            $collection = IconModel::findMultipleByIds(array_unique($amenityIconsMap));
+            $icons      = [];
+
+            if ($collection) {
+                foreach ($collection as $iconModel) {
+                    $icons[$iconModel->id] = $iconModel->alias ?: $iconModel->id;
+                }
+
+                foreach ($amenityIconsMap as $amenity => $iconId) {
+                    if (isset($icons[$iconId])) {
+                        $amenityIconsMap[$amenity] = $icons[$iconId];
+                    }
+                }
+            }
+        }
+
+        return $amenityIconsMap;
+    }
+
+    /**
+     * Filter the amenity icons config.
+     *
+     * @param mixed $amenityIconsConfig Raw config from the db.
+     *
+     * @return array
+     */
+    private function filterAmenityIconsConfig($amenityIconsConfig)
+    {
+        $amenityIconsConfig = deserialize($amenityIconsConfig, true);
+        $amenityIconsMap    = [];
+
+        foreach ($amenityIconsConfig as $config) {
+            if (!$config['amenity'] || !$config['icon']) {
+                continue;
+            }
+
+            $amenityIconsMap[$config['amenity']] = $config['icon'];
+        }
+
+        return $amenityIconsMap;
+    }
+}

src/Mapper/Layer/ProviderLayerMapper.php

@@ -0,0 +1,98 @@
+<?php
+
+/**
+ * @package    contao-leaflet-maps
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014-2016 netzmacht David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper\Layer;
+
+use Netzmacht\Contao\Leaflet\Filter\Filter;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\Contao\Leaflet\Mapper\OptionsBuilder;
+use Netzmacht\LeafletPHP\Definition;
+
+/**
+ * Class ProviderLayerMapper maps the layer model to the tile provider definition.
+ *
+ * @package Netzmacht\Contao\Leaflet\Mapper\Layer
+ */
+class ProviderLayerMapper extends AbstractLayerMapper
+{
+    /**
+     * Layer type.
+     *
+     * @var string
+     */
+    protected static $type = 'provider';
+
+    /**
+     * Registered providers.
+     *
+     * @var array
+     */
+    private $providers;
+
+    /**
+     * Construct.
+     *
+     * @param array $providers Registered providers.
+     */
+    public function __construct(array $providers)
+    {
+        $this->providers = $providers;
+
+        parent::__construct();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getClassName(\Model $model, DefinitionMapper $mapper, Filter $filter = null)
+    {
+        if (isset($this->providers[$model->tile_provider]['class'])) {
+            return $this->providers[$model->tile_provider]['class'];
+        }
+
+        return 'Netzmacht\LeafletPHP\Plugins\LeafletProviders\Provider';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function build(
+        Definition $definition,
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        Definition $parent = null
+    ) {
+        if (!empty($this->providers[$model->tile_provider]['options'])) {
+            OptionsBuilder::applyOptions(
+                $this->providers[$model->tile_provider]['options'],
+                $definition,
+                $model
+            );
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function buildConstructArguments(
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        $elementId = null
+    ) {
+        return array(
+            $model->alias ?: ('layer_' . $model->id),
+            $model->tile_provider,
+            $model->tile_provider_variant ?: null
+        );
+    }
+}

src/Mapper/Layer/ReferenceLayerMapper.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * @package    contao-leaflet-maps
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014-2016 netzmacht David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper\Layer;
+
+use Netzmacht\Contao\Leaflet\Filter\Filter;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\Contao\Leaflet\Model\LayerModel;
+use Netzmacht\LeafletPHP\Definition;
+
+/**
+ * Class ReferenceLayerMapper maps an reference layer to another layer.
+ *
+ * @package Netzmacht\Contao\Leaflet\Mapper\Layer
+ */
+class ReferenceLayerMapper extends AbstractLayerMapper
+{
+    /**
+     * Layer type.
+     *
+     * @var string
+     */
+    protected static $type = 'reference';
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handle(
+        $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        $elementId = null,
+        Definition $parent = null
+    ) {
+        $reference = LayerModel::findByPk($model->reference);
+
+        if (!$reference || !$reference->active) {
+            return null;
+        }
+
+        $elementId = $model->standalone ? $this->getElementId($model, $elementId) : null;
+
+        return $mapper->handle($reference, $filter, $elementId);
+    }
+}

src/Mapper/Layer/TileLayerMapper.php

@@ -0,0 +1,105 @@
+<?php
+
+/**
+ * @package    contao-leaflet-maps
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014-2016 netzmacht David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper\Layer;
+
+use Netzmacht\Contao\Leaflet\Filter\Filter;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\LeafletPHP\Definition;
+use Netzmacht\LeafletPHP\Definition\Raster\TileLayer;
+use Netzmacht\LeafletPHP\Value\LatLngBounds;
+
+/**
+ * Class TileLayerMapper maps the database model to the tile layer definition.
+ *
+ * @package Netzmacht\Contao\Leaflet\Mapper\Layer
+ */
+class TileLayerMapper extends AbstractLayerMapper
+{
+    /**
+     * The definition class.
+     *
+     * @var string
+     */
+    protected static $definitionClass = 'Netzmacht\LeafletPHP\Definition\Raster\TileLayer';
+
+    /**
+     * The layer type.
+     *
+     * @var string
+     */
+    protected static $type = 'tile';
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function initialize()
+    {
+        parent::initialize();
+
+        $this->optionsBuilder
+            ->addConditionalOption('minZoom')
+            ->addConditionalOption('maxZoom')
+            ->addConditionalOption('maxNativeZoom')
+            ->addConditionalOption('tileSize')
+            ->addConditionalOption('subdomain')
+            ->addConditionalOption('errorTileUrl')
+            ->addOptions('attribution', 'tms', 'continuousWorld', 'noWrap', 'zoomReverse')
+            ->addConditionalOption('zoomOffset')
+            ->addConditionalOption('opacity')
+            ->addOption('zIndex')
+            ->addOptions('unloadvisibleTiles', 'updateWhenIdle', 'detectRetina', 'reuseTiles');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function buildConstructArguments(
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        $elementId = null
+    ) {
+        $arguments = parent::buildConstructArguments($model, $mapper, $filter, $elementId);
+
+        $arguments[] = $model->tileUrl;
+
+        return $arguments;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function build(
+        Definition $definition,
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        Definition $parent = null
+    ) {
+        parent::build($definition, $model, $mapper, $filter, $parent);
+
+        /** @var TileLayer $definition */
+        $filter = deserialize($model->bounds);
+
+        if ($filter[0] && $filter[1]) {
+            $filter = array_map(
+                function ($value) {
+                    return explode(',', $value, 3);
+                },
+                $filter
+            );
+
+            $filter = LatLngBounds::fromArray($filter);
+            $definition->setBounds($filter);
+        }
+    }
+}

src/Mapper/Layer/VectorsLayerMapper.php

@@ -0,0 +1,180 @@
+<?php
+
+/**
+ * @package    contao-leaflet-maps
+ * @author     David Molineus <david.molineus@netzmacht.de>
+ * @copyright  2014-2016 netzmacht David Molineus
+ * @license    LGPL 3.0
+ * @filesource
+ *
+ */
+
+namespace Netzmacht\Contao\Leaflet\Mapper\Layer;
+
+use Netzmacht\Contao\Leaflet\Filter\Filter;
+use Netzmacht\Contao\Leaflet\Mapper\DefinitionMapper;
+use Netzmacht\Contao\Leaflet\Mapper\GeoJsonMapper;
+use Netzmacht\Contao\Leaflet\Model\VectorModel;
+use Netzmacht\Contao\Leaflet\Frontend\RequestUrl;
+use Netzmacht\JavascriptBuilder\Type\Expression;
+use Netzmacht\LeafletPHP\Definition;
+use Netzmacht\LeafletPHP\Value\GeoJson\FeatureCollection;
+use Netzmacht\LeafletPHP\Definition\Group\GeoJson;
+use Netzmacht\LeafletPHP\Definition\Vector;
+
+/**
+ * Class VectorsLayerMapper maps the layer model for the Vectors layer definition.
+ *
+ * @package Netzmacht\Contao\Leaflet\Mapper\Layer
+ */
+class VectorsLayerMapper extends AbstractLayerMapper implements GeoJsonMapper
+{
+    /**
+     * Layer type.
+     *
+     * @var string
+     */
+    protected static $type = 'vectors';
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getClassName(\Model $model, DefinitionMapper $mapper, Filter $filter = null)
+    {
+        if ($model->deferred) {
+            return 'Netzmacht\LeafletPHP\Plugins\Omnivore\GeoJson';
+        }
+
+        return 'Netzmacht\LeafletPHP\Definition\Group\GeoJson';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function buildConstructArguments(
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        $elementId = null
+    ) {
+        if ($model->deferred) {
+            $options = array();
+
+            if ($model->pointToLayer) {
+                $options['pointToLayer'] = new Expression($model->pointToLayer);
+            }
+
+            if ($model->onEachFeature) {
+                $options['onEachFeature'] = new Expression($model->onEachFeature);
+            }
+
+            if ($model->boundsMode) {
+                $options['boundsMode'] = $model->boundsMode;
+            }
+
+            if (!empty($options)) {
+                $layer = new GeoJson($this->getElementId($model, $elementId));
+                $layer->setOptions($options);
+
+                return array(
+                    $this->getElementId($model, $elementId),
+                    RequestUrl::create($model->id, null, null, $filter),
+                    array(),
+                    $layer
+                );
+            }
+
+            return array(
+                $this->getElementId($model, $elementId),
+                RequestUrl::create($model->id, null, null, $filter)
+            );
+        }
+
+        return parent::buildConstructArguments($model, $mapper, $filter, $elementId);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function build(
+        Definition $definition,
+        \Model $model,
+        DefinitionMapper $mapper,
+        Filter $filter = null,
+        Definition $parent = null
+    ) {
+        if ($definition instanceof GeoJson) {
+            $collection = $this->loadVectorModels($model);
+
+            if ($model->boundsMode) {
+                $definition->setOption('boundsMode', $model->boundsMode);
+            }
+
+            if ($collection) {
+                foreach ($collection as $item) {
+                    $vector  = $mapper->handle($item);
+                    $feature = $mapper->convertToGeoJsonFeature($vector, $item);
+
+                    if ($feature) {
+                        $definition->addData($feature, true);
+                    }
+                }
+            }
+
+            $this->addCallbacks($definition, $model);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handleGeoJson(\Model $model, DefinitionMapper $mapper, Filter $filter = null)
+    {
+        $definition = new FeatureCollection();
+        $collection = $this->loadVectorModels($model);
+
+        if ($collection) {
+            foreach ($collection as $item) {
+                $vector  = $mapper->handle($item);
+                $feature = $mapper->convertToGeoJsonFeature($vector, $item);
+
+                if ($feature) {
+                    $definition->addFeature($feature, true);
+                }
+            }
+        }
+
+        return $definition;
+    }
+
+    /**
+     * Load vector models.
+     *
+     * @param \Model $model The layer model.
+     *
+     * @return \Model\Collection|null
+     */
+    protected function loadVectorModels(\Model $model)
+    {
+        return VectorModel::findActiveBy('pid', $model->id, array('order' => 'sorting'));
+    }
+
+    /**
+     * Add javascript callbacks.
+     *
+     * @param GeoJson $definition The definition.
+     * @param \Model  $model      The database model.
+     *
+     * @return void
+     */
+    protected function addCallbacks(GeoJson $definition, \Model $model)
+    {
+        if ($model->pointToLayer) {
+            $definition->setPointToLayer(new Expression($model->pointToLayer));
+        }
+
+        if ($model->onEachFeature) {
+            $definition->setOnEachFeature(new Expression($model->onEachFeature));
+        }
+    }
+}