mirror of
https://forge.chapril.org/tykayn/osm-commerces
synced 2025-06-20 01:44:42 +02:00
742 lines
No EOL
28 KiB
Twig
742 lines
No EOL
28 KiB
Twig
{% extends 'base.html.twig' %}
|
|
|
|
{% block title %}{{ 'display.stats'|trans }}- {{ stats.zone }}
|
|
{{ stats.name }} {% endblock %}
|
|
|
|
{% block stylesheets %}
|
|
{{ parent() }}
|
|
<link href='{{ asset('js/maplibre/maplibre-gl.css') }}' rel='stylesheet' />
|
|
<style>
|
|
.completion-circle {
|
|
fill-opacity: 0.6;
|
|
stroke: #fff;
|
|
stroke-width: 3;
|
|
}
|
|
#distribution_completion {
|
|
height: 300px;
|
|
margin: 20px 0;
|
|
}
|
|
.completion-info {
|
|
margin-bottom: 2rem;
|
|
}
|
|
</style>
|
|
{% endblock %}
|
|
|
|
{% block body %}
|
|
<div class="container">
|
|
<div class="mt-4 p-4">
|
|
<div class="row">
|
|
<div class="col-md-6 col-12">
|
|
<h1 class="title">{{ 'display.stats'|trans }} - {{ stats.zone }}
|
|
{{ stats.name }} - {{ stats.completionPercent }}% complété</h1>
|
|
</div>
|
|
<div class="col-md-6 col-12">
|
|
<a href="{{ path('app_admin_labourer', {'zip_code': stats.zone}) }}" class="btn btn-primary" id="labourer">Labourer les mises à jour</a>
|
|
<button id="openInJOSM" class="btn btn-secondary ms-2">
|
|
<i class="bi bi-map"></i> Ouvrir dans JOSM
|
|
</button>
|
|
</div>
|
|
</div>
|
|
<div class="row">
|
|
<div class="col-md-3 col-12">
|
|
<span class="badge {% if stats.getCompletionPercent() > 85 %}bg-success{% else %}bg-warning{% endif %}">
|
|
{{ stats.getCompletionPercent() }} %
|
|
</span>
|
|
complété sur les critères donnés.
|
|
</div>
|
|
<div class="col-md-3 col-12">
|
|
<span class="badge bg-primary">
|
|
<i class="bi bi-building"></i> {{ stats.places | length}}
|
|
</span>commerces dans la zone.
|
|
</div>
|
|
<div class="col-md-3 col-12">
|
|
<span class="badge bg-primary">
|
|
<i class="bi bi-clock"></i> {{ stats.getAvecHoraires() }}
|
|
</span>
|
|
commerces avec horaires.
|
|
</div>
|
|
<div class="col-md-3 col-12">
|
|
<span class="badge bg-primary">
|
|
<i class="bi bi-map"></i> {{ stats.getAvecAdresse() }}
|
|
</span>
|
|
commerces avec adresse.
|
|
</div>
|
|
<div class="col-md-3 col-12">
|
|
<span class="badge bg-primary">
|
|
<i class="bi bi-globe"></i> {{ stats.getAvecSite() }}
|
|
</span>
|
|
commerces avec site web renseigné.
|
|
</div>
|
|
<div class="col-md-3 col-12">
|
|
<span class="badge bg-primary">
|
|
<i class="bi bi-arrow-up-right"></i>
|
|
{{ stats.getAvecAccessibilite() }}
|
|
</span>
|
|
commerces avec accessibilité PMR renseignée.
|
|
</div>
|
|
<div class="col-md-3 col-12">
|
|
<span class="badge bg-primary">
|
|
<i class="bi bi-chat-dots"></i> {{ stats.getAvecNote() }}
|
|
</span>
|
|
commerces avec note renseignée.
|
|
</div>
|
|
</div>
|
|
|
|
<div class="completion-info mt-4">
|
|
<div class="alert alert-info">
|
|
<div class="d-flex align-items-center" style="cursor: pointer;" onclick="toggleCompletionInfo()">
|
|
<i class="bi bi-info-circle me-2"></i>
|
|
<h4 class="alert-heading mb-0">Comment est calculé le score de complétion ?</h4>
|
|
<i class="bi bi-chevron-down ms-auto" id="completionInfoIcon"></i>
|
|
</div>
|
|
<div id="completionInfoContent" style="display: none;" class="mt-3">
|
|
<p>Le score de complétion est calculé en fonction de plusieurs critères :</p>
|
|
<ul>
|
|
<li>Nom du commerce (obligatoire)</li>
|
|
<li>Adresse complète (numéro, rue, code postal)</li>
|
|
<li>Horaires d'ouverture</li>
|
|
<li>Site web</li>
|
|
<li>Numéro de téléphone</li>
|
|
<li>Accessibilité PMR</li>
|
|
<li>Note descriptive</li>
|
|
</ul>
|
|
<p>Chaque critère rempli augmente le score de complétion. Un commerce parfaitement renseigné aura un score de 100%.</p>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
<div id="maploader">
|
|
<div class="spinner-border" role="status">
|
|
<i class="bi bi-load bi-spin"></i>
|
|
<span class="visually-hidden">Chargement de la carte...</span>
|
|
</div>
|
|
</div>
|
|
<div class="d-flex justify-content-end mb-2">
|
|
<div class="btn-group" role="group">
|
|
<button type="button" class="btn btn-outline-primary" id="circleMarkersBtn">
|
|
<i class="bi bi-circle"></i> Cercles
|
|
</button>
|
|
<button type="button" class="btn btn-outline-primary active" id="dropMarkersBtn">
|
|
<i class="bi bi-geo-alt"></i> Gouttes
|
|
</button>
|
|
</div>
|
|
</div>
|
|
<div id="map" class="mt-4" style="height: 400px;"></div>
|
|
<div id="attribution">
|
|
<a href="https://www.openstreetmap.org/copyright">Données OpenStreetMap</a>
|
|
</div>
|
|
</div>
|
|
<div class="card mt-4">
|
|
|
|
<div id="distribution_completion" class="mt-4 mb-4"></div>
|
|
|
|
<div class="row">
|
|
<div class="col-md-6 col-12">
|
|
<h1 class="card-title p-4">Tableau des {{ stats.places |length }} lieux</h1>
|
|
</div>
|
|
<div class="col-md-6 col-12">
|
|
<a class="btn btn-primary pull-right mt-4" href="{{ path('app_admin_export_csv', {'zip_code': stats.zone}) }}" class="btn btn-primary">
|
|
<i class="bi bi-filetype-csv"></i>
|
|
Exporter en CSV
|
|
</a>
|
|
</div>
|
|
</div>
|
|
<table class="table table-bordered table-striped table-hover table-responsive js-sort-table">
|
|
{% include 'admin/stats/table-head.html.twig' %}
|
|
<tbody>
|
|
{% for commerce in stats.places %}
|
|
{% include 'admin/stats/row.html.twig' %}
|
|
{% endfor %}
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
|
|
<div class="card mt-4">
|
|
<div class="card-header">
|
|
<h2>Requête Overpass</h2>
|
|
</div>
|
|
<div class="card-body">
|
|
<pre class="p-4 bg-light">
|
|
{{query_places|raw}}
|
|
</pre>
|
|
<a href="https://overpass-turbo.eu/?Q={{ query_places|url_encode }}" class="btn btn-primary" target="_blank">
|
|
<i class="bi bi-box-arrow-up-right"></i> Exécuter dans Overpass Turbo
|
|
</a>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
<!-- Bouton caché pour JOSM -->
|
|
<a id="josmButton" style="display: none;"></a>
|
|
|
|
<script src='{{ asset('js/maplibre/maplibre-gl.js') }}'></script>
|
|
<script src='{{ asset('js/turf/turf.min.js') }}'></script>
|
|
<script src="{{ asset('js/chartjs/chart.umd.js') }}"></script>
|
|
<script src="{{ asset('js/app.js') }}"></script>
|
|
<script>
|
|
const request = `{{query_places|raw}}`;
|
|
const zip_code = `{{stats.zone}}`;
|
|
let mapElements = [];
|
|
let map_is_loaded = false;
|
|
let features = [];
|
|
let maplibre;
|
|
let map;
|
|
let overpassData = {}; // Stockage des données Overpass
|
|
let currentMarkerType = 'drop'; // Type de marqueur actuel
|
|
let dropMarkers = []; // Tableau pour stocker les marqueurs en goutte
|
|
let contextMenu = null; // Menu contextuel
|
|
|
|
function getCompletionColor(completion) {
|
|
if (completion === undefined || completion === null) {
|
|
return '#808080'; // Gris pour pas d'information
|
|
}
|
|
// Convertir le pourcentage en couleur verte (0% = blanc, 100% = vert foncé)
|
|
const intensity = Math.floor((completion / 100) * 255);
|
|
return `rgb(0, ${intensity}, 0)`;
|
|
}
|
|
|
|
function calculateCompletion(element) {
|
|
let completionCount = 0;
|
|
let totalFields = 0;
|
|
|
|
const fieldsToCheck = [
|
|
'name',
|
|
'contact:street',
|
|
'contact:housenumber',
|
|
'opening_hours',
|
|
'contact:website',
|
|
'contact:phone',
|
|
'wheelchair'
|
|
];
|
|
|
|
fieldsToCheck.forEach(field => {
|
|
totalFields++;
|
|
if (element.tags && element.tags[field]) {
|
|
completionCount++;
|
|
}
|
|
});
|
|
|
|
return (completionCount / totalFields) * 100;
|
|
}
|
|
|
|
function createPopupContent(element) {
|
|
let content = `
|
|
<div class="mb-2">
|
|
<a class="btn btn-primary" href="/admin/placeType/${element.type}/${element.id}">
|
|
<i class="bi bi-pencil"></i> ${element.tags?.name || 'Sans nom'}
|
|
</a>
|
|
<a class="btn btn-secondary ms-2" href="https://openstreetmap.org/${element.type}/${element.id}">
|
|
<i class="bi bi-map"></i> OSM
|
|
</a>
|
|
</div>
|
|
`;
|
|
|
|
content += '<table class="table table-sm">';
|
|
|
|
// Ajouter tous les tags
|
|
if (element.tags) {
|
|
for (const tag in element.tags) {
|
|
content += `<tr><td><strong>${tag}</strong></td><td>${element.tags[tag]}</td></tr>`;
|
|
}
|
|
}
|
|
|
|
content += '</table>';
|
|
return content;
|
|
}
|
|
|
|
function calculateCompletionDistribution(elements) {
|
|
// Créer des buckets de 10% (0-10%, 10-20%, etc.)
|
|
const buckets = Array(11).fill(0);
|
|
|
|
elements.forEach(element => {
|
|
const completion = calculateCompletion(element);
|
|
const bucketIndex = Math.floor(completion / 10);
|
|
buckets[bucketIndex]++;
|
|
});
|
|
|
|
return buckets;
|
|
}
|
|
|
|
function createCompletionChart(elements) {
|
|
const distribution = calculateCompletionDistribution(elements);
|
|
const ctx = document.createElement('canvas');
|
|
document.getElementById('distribution_completion').appendChild(ctx);
|
|
|
|
new Chart(ctx, {
|
|
type: 'line',
|
|
data: {
|
|
labels: ['0-10%', '10-20%', '20-30%', '30-40%', '40-50%', '50-60%', '60-70%', '70-80%', '80-90%', '90-100%'],
|
|
datasets: [{
|
|
label: 'Nombre de commerces',
|
|
data: distribution,
|
|
backgroundColor: 'rgba(0, 128, 0, 0.1)',
|
|
borderColor: 'rgba(0, 128, 0, 1)',
|
|
borderWidth: 2,
|
|
tension: 0.4,
|
|
fill: true,
|
|
pointBackgroundColor: 'rgba(0, 128, 0, 1)',
|
|
pointBorderColor: '#fff',
|
|
pointBorderWidth: 2,
|
|
pointRadius: 4,
|
|
pointHoverRadius: 6
|
|
}]
|
|
},
|
|
options: {
|
|
responsive: true,
|
|
maintainAspectRatio: false,
|
|
scales: {
|
|
y: {
|
|
beginAtZero: true,
|
|
title: {
|
|
display: true,
|
|
text: 'Nombre de commerces'
|
|
}
|
|
},
|
|
x: {
|
|
title: {
|
|
display: true,
|
|
text: 'Taux de complétion'
|
|
}
|
|
}
|
|
},
|
|
plugins: {
|
|
title: {
|
|
display: true,
|
|
text: 'Distribution du taux de complétion des commerces'
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
function createJOSMQuery(elements){
|
|
let query = '';
|
|
elements.forEach(element => {
|
|
query += `${element.type}${element.id},`;
|
|
});
|
|
// Enlever la virgule finale
|
|
query = query.replace(/,$/, '');
|
|
console.log('josm query', query);
|
|
return query;
|
|
}
|
|
|
|
let josm_elements = [];
|
|
features = [];
|
|
|
|
async function loadPlaces(map) {
|
|
try {
|
|
const request = `{{query_places |raw}}`;
|
|
const response = await fetch('https://overpass-api.de/api/interpreter', {
|
|
method: 'POST',
|
|
body: request
|
|
});
|
|
if (!response.ok) {
|
|
throw new Error(`HTTP error! status: ${response.status}`);
|
|
}
|
|
const data = await response.json();
|
|
console.log('Données reçues:', data);
|
|
|
|
// Stocker les données Overpass
|
|
data.elements.forEach(element => {
|
|
overpassData[element.id] = element;
|
|
});
|
|
|
|
// Mettre à jour les marqueurs
|
|
features = [];
|
|
josm_elements = [];
|
|
data.elements.forEach(element => {
|
|
const lat = element.lat || (element.center && element.center.lat);
|
|
const lon = element.lon || (element.center && element.center.lon);
|
|
if (lat && lon) {
|
|
const completion = calculateCompletion(element);
|
|
|
|
const feature = {
|
|
id: `marker-${element.id}`,
|
|
type: 'Feature',
|
|
properties: {
|
|
id: element.id,
|
|
name: element.tags?.name || 'Sans nom',
|
|
completion: completion,
|
|
center: [lon, lat]
|
|
},
|
|
geometry: {
|
|
type: 'Point',
|
|
coordinates: [lon, lat]
|
|
}
|
|
};
|
|
features.push(feature);
|
|
josm_elements.push(element);
|
|
}
|
|
});
|
|
|
|
// Afficher les marqueurs selon le type actuel
|
|
updateMarkers();
|
|
|
|
// Ajuster la vue pour inclure tous les points
|
|
const points = features.map(f => f.properties.center);
|
|
if (points.length > 0) {
|
|
const bounds = new maplibregl.LngLatBounds(points[0], points[0]);
|
|
points.forEach(point => bounds.extend(point));
|
|
|
|
if (bounds?._sw && bounds?._ne) {
|
|
map.fitBounds(bounds, {
|
|
padding: 50,
|
|
maxZoom: 15
|
|
});
|
|
} else {
|
|
console.warn('Bounds invalides, utilisation des coordonnées par défaut');
|
|
}
|
|
}
|
|
|
|
createCompletionChart(data.elements);
|
|
|
|
// Cacher le spinner une fois le chargement terminé
|
|
document.getElementById('maploader').style.display = 'none';
|
|
|
|
} catch (error) {
|
|
console.error('Erreur lors du chargement des lieux:', error);
|
|
}
|
|
}
|
|
|
|
function updateMarkers() {
|
|
// Supprimer tous les marqueurs existants
|
|
features.forEach(feature => {
|
|
const layerId = `marker-${feature.properties.id}`;
|
|
// Supprimer d'abord la couche
|
|
if (map.getLayer(layerId)) {
|
|
map.removeLayer(layerId);
|
|
}
|
|
// Puis supprimer la source
|
|
if (map.getSource(layerId)) {
|
|
map.removeSource(layerId);
|
|
}
|
|
});
|
|
|
|
// Supprimer tous les marqueurs en goutte existants
|
|
dropMarkers.forEach(marker => marker.remove());
|
|
dropMarkers = [];
|
|
|
|
if (currentMarkerType === 'circle') {
|
|
// Afficher les cercles
|
|
features.forEach(feature => {
|
|
const layerId = `marker-${feature.properties.id}`;
|
|
const circle = turf.circle(
|
|
feature.properties.center,
|
|
5/1000,
|
|
{ steps: 64, units: 'kilometers' }
|
|
);
|
|
|
|
map.addSource(layerId, {
|
|
'type': 'geojson',
|
|
'data': circle
|
|
});
|
|
|
|
map.addLayer({
|
|
'id': layerId,
|
|
'type': 'fill',
|
|
'source': layerId,
|
|
'paint': {
|
|
'fill-color': getCompletionColor(feature.properties.completion),
|
|
'fill-opacity': 0.7
|
|
}
|
|
});
|
|
});
|
|
|
|
// Ajouter les popups sur les cercles
|
|
map.on('click', function(e) {
|
|
const clickedFeatures = map.queryRenderedFeatures(e.point, {
|
|
layers: features.map(f => `marker-${f.properties.id}`)
|
|
});
|
|
|
|
if (clickedFeatures.length > 0) {
|
|
const feature = clickedFeatures[0];
|
|
const elementId = feature.layer.id.replace('marker-', '');
|
|
const element = overpassData[elementId];
|
|
|
|
if (element) {
|
|
// Créer le contenu de la popup
|
|
const popupContent = createPopupContent(element);
|
|
|
|
new maplibregl.Popup()
|
|
.setLngLat(e.lngLat)
|
|
.setHTML(popupContent)
|
|
.addTo(map);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
// Afficher les marqueurs en goutte
|
|
features.forEach(feature => {
|
|
const element = overpassData[feature.properties.id];
|
|
const popupContent = element ? createPopupContent(element) : `<h1>${feature.properties.name}</h1>`;
|
|
|
|
const marker = new maplibregl.Marker({
|
|
color: getCompletionColor(feature.properties.completion)
|
|
})
|
|
.setLngLat(feature.properties.center)
|
|
.setPopup(new maplibregl.Popup({ offset: 25 })
|
|
.setHTML(popupContent))
|
|
.addTo(map);
|
|
dropMarkers.push(marker);
|
|
});
|
|
}
|
|
}
|
|
|
|
function draw_circle_containing_all_features(map) {
|
|
if (features.length === 0) return;
|
|
|
|
// Calculer le centre à partir de toutes les features
|
|
const center = features.reduce((acc, feature) => {
|
|
return [
|
|
acc[0] + feature.properties.center[0],
|
|
acc[1] + feature.properties.center[1]
|
|
];
|
|
}, [0, 0]).map(coord => coord / features.length);
|
|
|
|
// Calculer le rayon nécessaire pour couvrir tous les points
|
|
const radius = features.reduce((maxRadius, feature) => {
|
|
const distance = turf.distance(
|
|
center,
|
|
feature.properties.center,
|
|
{ units: 'kilometers' }
|
|
);
|
|
return Math.max(maxRadius, distance);
|
|
}, 0);
|
|
|
|
const circle = turf.circle(center, radius, { steps: 64, units: 'kilometers' });
|
|
map.addSource('circle', { type: 'geojson', data: circle });
|
|
map.addLayer({
|
|
id: 'circle',
|
|
type: 'fill',
|
|
source: 'circle',
|
|
paint: {
|
|
'fill-color': 'blue',
|
|
'fill-opacity': 0.25
|
|
}
|
|
});
|
|
|
|
// Ajouter un marqueur au centre du cercle
|
|
new maplibregl.Marker()
|
|
.setLngLat(center)
|
|
.addTo(map);
|
|
}
|
|
|
|
function updateCircles(map) {
|
|
if (!map) return;
|
|
|
|
const zoom = map.getZoom();
|
|
// Ajuster la taille de base en fonction du zoom
|
|
// Plus le zoom est faible (loin), plus le rayon est grand
|
|
const baseRadius = Math.min(100, 200 / Math.pow(1.2, zoom));
|
|
|
|
features.forEach(feature => {
|
|
const source = map.getSource(feature.id);
|
|
if (!source) return;
|
|
|
|
const completion = feature.properties.completion;
|
|
const radius = baseRadius * (1 + (completion / 100));
|
|
|
|
// Mettre à jour le rayon du cercle
|
|
const circle = turf.circle(
|
|
feature.properties.center,
|
|
0.5* radius / 1000, // Convertir en kilomètres
|
|
{ steps: 64, units: 'kilometers' }
|
|
);
|
|
|
|
// Mettre à jour la source avec le nouveau cercle
|
|
source.setData(circle);
|
|
|
|
// Mettre à jour la couleur du cercle
|
|
const layer = map.getLayer(feature.id);
|
|
if (layer) {
|
|
map.setPaintProperty(feature.id, 'fill-color', getCompletionColor(completion));
|
|
}
|
|
});
|
|
}
|
|
|
|
function openJOSMQuery(map, query) {
|
|
const bounds = map.getBounds();
|
|
|
|
const josmUrl = `http://localhost:8111/load_object?` +
|
|
|
|
`objects=${query}`;
|
|
|
|
// Créer un élément <a> temporaire
|
|
const tempLink = document.createElement('a');
|
|
tempLink.style.display = 'none';
|
|
document.body.appendChild(tempLink);
|
|
|
|
console.log('josmUrl', josmUrl);
|
|
|
|
tempLink.href = josmUrl;
|
|
tempLink.click();
|
|
document.body.removeChild(tempLink);
|
|
}
|
|
|
|
function openInJOSM() {
|
|
if (josm_elements.length === 0) {
|
|
alert('Veuillez sélectionner au moins un élément');
|
|
return;
|
|
}
|
|
const query = createJOSMQuery(josm_elements);
|
|
console.log('map', map);
|
|
openJOSMQuery(map, query);
|
|
}
|
|
|
|
document.addEventListener('DOMContentLoaded', function() {
|
|
console.log('DOMContentLoaded');
|
|
|
|
maplibre = new maplibregl.Map({
|
|
container: 'map',
|
|
style: 'https://api.maptiler.com/maps/streets-v2/style.json?key={{ maptiler_token }}',
|
|
center: [2.3488, 48.8534],
|
|
zoom: 12
|
|
});
|
|
map = maplibre;
|
|
|
|
// Créer le menu contextuel
|
|
contextMenu = document.createElement('div');
|
|
contextMenu.id = 'context-menu';
|
|
contextMenu.style.display = 'none';
|
|
contextMenu.style.position = 'absolute';
|
|
contextMenu.style.backgroundColor = 'white';
|
|
contextMenu.style.border = '1px solid #ccc';
|
|
contextMenu.style.padding = '10px';
|
|
contextMenu.style.borderRadius = '4px';
|
|
contextMenu.style.boxShadow = '0 2px 4px rgba(0,0,0,0.2)';
|
|
contextMenu.style.zIndex = '1000';
|
|
document.body.appendChild(contextMenu);
|
|
|
|
// Gestionnaire de clic droit sur la carte
|
|
map.on('contextmenu', async function(e) {
|
|
e.preventDefault();
|
|
|
|
// Vérifier si le clic est sur un marqueur
|
|
const clickedFeatures = map.queryRenderedFeatures(e.point, {
|
|
layers: features.map(f => `marker-${f.properties.id}`)
|
|
});
|
|
|
|
if (clickedFeatures.length > 0) {
|
|
return; // Ne rien faire si on clique sur un marqueur
|
|
}
|
|
|
|
// Afficher le menu contextuel
|
|
contextMenu.style.display = 'block';
|
|
|
|
// Obtenir la position de la carte dans la page
|
|
const mapContainer = map.getContainer();
|
|
const mapRect = mapContainer.getBoundingClientRect();
|
|
|
|
// Calculer la position relative au conteneur de la carte
|
|
const x = e.point.x + mapRect.left;
|
|
const y = e.point.y + mapRect.top;
|
|
|
|
// Positionner le menu contextuel
|
|
contextMenu.style.left = `${x}px`;
|
|
contextMenu.style.top = `${y}px`;
|
|
|
|
contextMenu.innerHTML = '<div class="spinner-border spinner-border-sm" role="status"></div> Recherche du code INSEE...';
|
|
|
|
try {
|
|
// Récupérer les coordonnées du clic
|
|
const { lng, lat } = e.lngLat;
|
|
|
|
// Appeler l'API pour obtenir le code INSEE
|
|
const response = await fetch(`https://api-adresse.data.gouv.fr/reverse/?lon=${lng}&lat=${lat}`);
|
|
const data = await response.json();
|
|
|
|
if (data.features && data.features.length > 0) {
|
|
const feature = data.features[0];
|
|
const city = feature.properties.city;
|
|
const inseeCode = feature.properties.citycode;
|
|
|
|
contextMenu.innerHTML = `
|
|
<div class="mb-2">
|
|
<strong>Ville :</strong> ${city}<br>
|
|
<strong>Code INSEE :</strong> ${inseeCode}
|
|
</div>
|
|
<a href="/admin/labourer/${inseeCode}" class="btn btn-primary btn-sm">
|
|
<i class="bi bi-tractor"></i> Labourer cette zone
|
|
</a>
|
|
`;
|
|
} else {
|
|
contextMenu.innerHTML = 'Aucune information trouvée pour cette position';
|
|
}
|
|
} catch (error) {
|
|
console.error('Erreur lors de la recherche du code INSEE:', error);
|
|
contextMenu.innerHTML = 'Erreur lors de la recherche du code INSEE';
|
|
}
|
|
});
|
|
|
|
// Fermer le menu contextuel lors d'un clic ailleurs
|
|
document.addEventListener('click', function(e) {
|
|
if (contextMenu && !contextMenu.contains(e.target)) {
|
|
contextMenu.style.display = 'none';
|
|
}
|
|
});
|
|
|
|
// Gestionnaires d'événements pour les boutons de type de marqueur
|
|
document.getElementById('circleMarkersBtn').addEventListener('click', function() {
|
|
currentMarkerType = 'circle';
|
|
this.classList.add('active');
|
|
document.getElementById('dropMarkersBtn').classList.remove('active');
|
|
updateMarkers();
|
|
});
|
|
|
|
document.getElementById('dropMarkersBtn').addEventListener('click', function() {
|
|
currentMarkerType = 'drop';
|
|
this.classList.add('active');
|
|
document.getElementById('circleMarkersBtn').classList.remove('active');
|
|
updateMarkers();
|
|
});
|
|
|
|
document.getElementById('openInJOSM').addEventListener('click', openInJOSM);
|
|
|
|
// Attendre que la carte soit chargée avant d'ajouter les écouteurs d'événements
|
|
map.on('load', function() {
|
|
console.log('Map loaded');
|
|
map_is_loaded = true;
|
|
// Changer le curseur au survol des marqueurs
|
|
map.on('mouseenter', function(e) {
|
|
const hoveredFeatures = map.queryRenderedFeatures(e.point, {
|
|
layers: features.map(f => `marker-${f.properties.id}`)
|
|
});
|
|
if (hoveredFeatures.length > 0) {
|
|
map.getCanvas().style.cursor = 'pointer';
|
|
}
|
|
});
|
|
|
|
map.on('mouseleave', function(e) {
|
|
const hoveredFeatures = map.queryRenderedFeatures(e.point, {
|
|
layers: features.map(f => `marker-${f.properties.id}`)
|
|
});
|
|
if (hoveredFeatures.length === 0) {
|
|
map.getCanvas().style.cursor = '';
|
|
}
|
|
});
|
|
|
|
// Charger les lieux
|
|
loadPlaces(map);
|
|
|
|
draw_circle_containing_all_features(map);
|
|
});
|
|
|
|
sortTable();
|
|
});
|
|
|
|
function toggleCompletionInfo() {
|
|
const content = document.getElementById('completionInfoContent');
|
|
const icon = document.getElementById('completionInfoIcon');
|
|
|
|
if (content.style.display === 'none') {
|
|
content.style.display = 'block';
|
|
icon.classList.remove('bi-chevron-down');
|
|
icon.classList.add('bi-chevron-up');
|
|
} else {
|
|
content.style.display = 'none';
|
|
icon.classList.remove('bi-chevron-up');
|
|
icon.classList.add('bi-chevron-down');
|
|
}
|
|
}
|
|
</script>
|
|
{% endblock %} |