-
-
-
- | {% translate "Code" %} |
- {% translate "Description" %} |
- {% translate "Auteur" %} |
- {% translate "Type" %} |
- {% translate "Mise à jour" %} |
-
-
-
- {% for control in controls %}
-
- | {{ control.control_code }} |
- {{ control.description }} |
- {{ control.control_author|short_name }} |
- {{ control.get_control_type_display }} |
- {{ control.updated_at|timezone:"Europe/Paris"|date:"d/m/Y H:i" }} |
-
- {% endfor %}
-
-
+
+
-{% endblock content%}
+
+
+
+
+
+
+
+
+
+ -
+
+
+
+ {% if is_add_control_allowed %}
+
+ {% endif %}
+
+
+
+
+
+
+ {% translate "Aucun contrôle chargé" %}
+
+
+
+ {% translate "Contenu limité à 5 000 éléments." %}
+
+
+
+
+
+ {% translate "Chargement..." %}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endblock content %}
{% block script %}
-
+
+
+
+
+
{% endblock script %}
\ No newline at end of file
diff --git a/loko/controls/tests.py b/loko/controls/tests.py
index 7ce503c..0a017cb 100644
--- a/loko/controls/tests.py
+++ b/loko/controls/tests.py
@@ -1,3 +1,218 @@
+import io
+import json
from django.test import TestCase
+from django.contrib.auth import get_user_model
+from django.urls import reverse
+from openpyxl import load_workbook
-# Create your tests here.
+from common.models import Thematic, Role, UserConfig, UserThematics
+from assets.models import AssetCategory
+from projects.models import Project, ProjectUserAccess
+from controls.models import Control, Remark
+
+User = get_user_model()
+
+
+class ControlsIndexTests(TestCase):
+ def setUp(self):
+ # Thematics
+ self.thematic_a = Thematic.objects.create(
+ code="THEME_A",
+ name_fr="Voirie",
+ name_nl="Wegenis",
+ icon="bi-cone-striped"
+ )
+ self.thematic_b = Thematic.objects.create(
+ code="THEME_B",
+ name_fr="Signalisation",
+ name_nl="Signalisatie",
+ icon="bi-signpost"
+ )
+
+ # Categories
+ self.cat_a = AssetCategory.objects.create(
+ thematic=self.thematic_a,
+ code="CAT_A",
+ name_fr="Trottoir",
+ name_nl="Voetpad"
+ )
+
+ # Users
+ self.admin_user = User.objects.create_user("admin_user", password="password123")
+ self.admin_config = UserConfig.objects.create(user=self.admin_user, is_intern=True)
+ self.admin_role, _ = Role.objects.get_or_create(name="admin")
+ self.admin_config.roles.add(self.admin_role)
+
+ self.internal_user = User.objects.create_user("internal_user", password="password123")
+ self.internal_config = UserConfig.objects.create(user=self.internal_user, is_intern=True)
+ UserThematics.objects.create(
+ user_config=self.internal_config,
+ thematic=self.thematic_a,
+ can_view_interventions=True
+ )
+
+ self.other_user = User.objects.create_user("other_user", password="password123")
+ self.other_config = UserConfig.objects.create(user=self.other_user, is_intern=False)
+
+ # Project
+ self.project = Project.objects.create(
+ name="Projet Test",
+ code="PRJ-001",
+ created_by=self.admin_user
+ )
+ ProjectUserAccess.objects.create(
+ project=self.project,
+ user=self.internal_user,
+ can_view=True
+ )
+
+ # Controls
+ self.ctrl1 = Control.objects.create(
+ control_code="CTRL-0001",
+ description="Contrôle bordure rue Royale",
+ location="Rue Royale 10",
+ status="in_progress",
+ control_type="control",
+ control_author=self.internal_user,
+ project=self.project,
+ lon=4.36,
+ lat=50.85,
+ visibility="intern"
+ )
+ self.ctrl1.thematics.add(self.thematic_a)
+ self.ctrl1.categories.add(self.cat_a)
+ Remark.objects.create(control=self.ctrl1, description="Remarque 1")
+
+ self.ctrl2 = Control.objects.create(
+ control_code="CTRL-0002",
+ description="Constat marquage au sol",
+ location="Avenue Louise 20",
+ status="to_be_processed",
+ control_type="statement",
+ control_author=self.admin_user,
+ lon=4.37,
+ lat=50.84,
+ visibility="all"
+ )
+ self.ctrl2.thematics.add(self.thematic_b)
+
+ self.ctrl_private = Control.objects.create(
+ control_code="CTRL-0003",
+ description="Contrôle privé",
+ status="information",
+ control_type="meeting_report",
+ control_author=self.admin_user,
+ visibility="private"
+ )
+
+ def test_controls_index_page_loads(self):
+ self.client.login(username="admin_user", password="password123")
+ response = self.client.get(reverse("controls:controls_index"))
+ self.assertEqual(response.status_code, 200)
+ self.assertTemplateUsed(response, "controls/controls_index.html")
+ self.assertIn("thematic_choices", response.context)
+ self.assertIn("status_choices", response.context)
+ self.assertIn("control_type_choices", response.context)
+ self.assertIn("category_choices", response.context)
+ self.assertIn("project_choices", response.context)
+
+ def test_controls_index_saved_preferences_redirect(self):
+ self.admin_config.control_list_filters = {"thematic": ["THEME_A"]}
+ self.admin_config.save()
+
+ self.client.login(username="admin_user", password="password123")
+ response = self.client.get(reverse("controls:controls_index"))
+ self.assertEqual(response.status_code, 302)
+ self.assertIn("thematic=THEME_A", response.url)
+
+ def test_controls_geojson_endpoint(self):
+ self.client.login(username="admin_user", password="password123")
+ response = self.client.get(reverse("controls:controls_geojson"))
+ self.assertEqual(response.status_code, 200)
+ data = response.json()
+ self.assertEqual(data["type"], "FeatureCollection")
+ self.assertTrue(len(data["features"]) >= 2)
+
+ # Check properties on first feature
+ feature = next(f for f in data["features"] if f["id"] == self.ctrl1.id)
+ self.assertEqual(feature["properties"]["control_code"], "CTRL-0001")
+ self.assertEqual(feature["properties"]["status"], "in_progress")
+ self.assertEqual(feature["properties"]["control_type"], "control")
+ self.assertEqual(feature["properties"]["project_name"], "Projet Test")
+ self.assertEqual(feature["properties"]["remarks_count"], 1)
+ self.assertEqual(feature["geometry"]["coordinates"], [4.36, 50.85])
+
+ def test_controls_geojson_filter_by_thematic(self):
+ self.client.login(username="admin_user", password="password123")
+ response = self.client.get(reverse("controls:controls_geojson"), {"thematic": ["THEME_A"]})
+ self.assertEqual(response.status_code, 200)
+ data = response.json()
+ codes = [f["properties"]["control_code"] for f in data["features"]]
+ self.assertIn("CTRL-0001", codes)
+ self.assertNotIn("CTRL-0002", codes)
+
+ def test_controls_geojson_filter_by_status_and_type(self):
+ self.client.login(username="admin_user", password="password123")
+ response = self.client.get(reverse("controls:controls_geojson"), {
+ "status": ["to_be_processed"],
+ "type": ["statement"]
+ })
+ self.assertEqual(response.status_code, 200)
+ data = response.json()
+ codes = [f["properties"]["control_code"] for f in data["features"]]
+ self.assertEqual(codes, ["CTRL-0002"])
+
+ def test_controls_geojson_filter_by_search_query(self):
+ self.client.login(username="admin_user", password="password123")
+ response = self.client.get(reverse("controls:controls_geojson"), {"q": "Royale"})
+ self.assertEqual(response.status_code, 200)
+ data = response.json()
+ codes = [f["properties"]["control_code"] for f in data["features"]]
+ self.assertEqual(codes, ["CTRL-0001"])
+
+ def test_controls_geojson_filter_mine(self):
+ self.client.login(username="internal_user", password="password123")
+ response = self.client.get(reverse("controls:controls_geojson"), {"mine": "1"})
+ self.assertEqual(response.status_code, 200)
+ data = response.json()
+ codes = [f["properties"]["control_code"] for f in data["features"]]
+ self.assertEqual(codes, ["CTRL-0001"])
+
+ def test_controls_geojson_permissions(self):
+ # Internal user without access to thematic B and not author of private control
+ self.client.login(username="internal_user", password="password123")
+ response = self.client.get(reverse("controls:controls_geojson"))
+ self.assertEqual(response.status_code, 200)
+ data = response.json()
+ codes = [f["properties"]["control_code"] for f in data["features"]]
+ self.assertIn("CTRL-0001", codes)
+ self.assertNotIn("CTRL-0003", codes) # private to admin_user
+
+ def test_controls_export_excel(self):
+ self.client.login(username="admin_user", password="password123")
+ response = self.client.get(reverse("controls:controls_export_excel"))
+ self.assertEqual(response.status_code, 200)
+ self.assertEqual(
+ response["Content-Type"],
+ "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+ )
+ wb = load_workbook(filename=io.BytesIO(response.content))
+ ws = wb.active
+ self.assertIn(ws.title, ["Contrôles", "Controls"])
+ self.assertGreaterEqual(ws.max_row, 2) # Header + rows
+
+ def test_save_control_list_preferences(self):
+ self.client.login(username="internal_user", password="password123")
+ payload = {
+ "filters": {"thematic": ["THEME_A"], "mine": "1"},
+ "sort": {"sortName": "created_at", "sortOrder": "asc"}
+ }
+ response = self.client.post(
+ reverse("common:save_control_list_preferences"),
+ data=json.dumps(payload),
+ content_type="application/json"
+ )
+ self.assertEqual(response.status_code, 200)
+ self.internal_config.refresh_from_db()
+ self.assertEqual(self.internal_config.control_list_filters, payload["filters"])
+ self.assertEqual(self.internal_config.control_list_sort, payload["sort"])
diff --git a/loko/controls/urls.py b/loko/controls/urls.py
index 5a0081e..a559ce7 100644
--- a/loko/controls/urls.py
+++ b/loko/controls/urls.py
@@ -6,6 +6,8 @@ app_name = "controls"
urlpatterns = [
path("", views.controls_index, name="controls_index"),
+ path("geojson/", views.controls_geojson, name="controls_geojson"),
+ path("export-excel/", views.controls_export_excel, name="controls_export_excel"),
path("service-worker.js", views.controls_service_worker, name="controls_service_worker"),
path("offline/", views.controls_offline, name="controls_offline"),
path('
/', views.controls_detail, name='controls_detail'),
diff --git a/loko/controls/views.py b/loko/controls/views.py
index 86b9bff..157f7d9 100644
--- a/loko/controls/views.py
+++ b/loko/controls/views.py
@@ -9,19 +9,20 @@ from django.shortcuts import render, get_object_or_404, redirect
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.cache import never_cache
from django.http import JsonResponse, FileResponse, HttpResponse, HttpResponseForbidden
-from django.views.decorators.http import require_POST
+from django.views.decorators.http import require_POST, require_GET
from django.conf import settings
from django.contrib.staticfiles import finders as staticfiles_finders
from pathlib import Path
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.utils.timezone import now
-from django.db.models import Q, Exists, OuterRef, Subquery
+from django.utils.translation import get_language
+from django.db.models import Q, Exists, OuterRef, Subquery, Count
from django.db import transaction
from django.urls import reverse
from django.utils.translation import gettext as _
-from django.contrib.gis.db.models.functions import Transform, Centroid
+from django.contrib.gis.db.models.functions import Transform, Centroid, AsGeoJSON
from pdf2image import convert_from_path
from PIL import Image
@@ -30,18 +31,22 @@ from common.private_files.helpers import build_private_url
from .views_reports_pdf import generate_control_pdf
-from .models import Control, Remark, RemarkImage, RemarkHistory, RemarkTag, ControlReferencePlan, ControlReport, ControlReportTemplate, Category, ControlQuantity
+from .models import (
+ Control, Remark, RemarkImage, RemarkHistory, RemarkTag,
+ ControlReferencePlan, ControlReport, ControlReportTemplate, Category, ControlQuantity,
+ CONTROL_STATUS_CHOICES, CONTROL_TYPE_CHOICES
+)
from .forms import ControlForm, RemarkForm, ControlReferencePlanForm, ControlReportTemplateForm, ControlQuantityForm, QuantityFormSet
from .permissions import control_view_required, control_add_required, user_can_add_control, control_change_required, user_can_change_control
from projects.models import Project, ProjectUserAccess, ProjectPhase
from projects.permissions import filter_viewable_projects_for_user
from interventions.models import Intervention
-from interventions.models import Intervention
-from common.models import UserConfig, UserThematics, UserContractAccess
+from common.models import UserConfig, UserThematics, UserContractAccess, Thematic
+from assets.models import AssetCategory
from contracts.models import ContractPost, Contract
-from common.utils import redirect_with_variant
+from common.utils import redirect_with_variant, get_short_name
logger = logging.getLogger(__name__)
@@ -184,87 +189,405 @@ def _read_service_worker_content():
return 'console.error("Controls service worker introuvable");'
-def controls_index(request):
- user = request.user
- variant = request.GET.get('v', 'desktop')
- if "/mobile/" in request.path:
- variant = 'mobile'
+_CONTROL_STATUS_BADGE_MAP = {
+ 'in_progress': 'warning',
+ 'information': 'info',
+ 'to_be_processed': 'danger',
+ 'processed': 'success',
+ 'validated': 'primary',
+ 'canceled': 'secondary',
+}
- # Admin
- is_admin = bool(getattr(user, "config", None) and (user.config.has_role("admin") or user.config.has_role("top_manager")))
+_CONTROL_STATUS_COLOR_MAP = {
+ 'in_progress': '#ffc107',
+ 'information': '#0dcaf0',
+ 'to_be_processed': '#dc3545',
+ 'processed': '#198754',
+ 'validated': '#0d6efd',
+ 'canceled': '#6c757d',
+}
- # Auteur
+_CONTROL_TYPE_BADGE_MAP = {
+ 'control': 'primary',
+ 'site_report': 'warning',
+ 'statement': 'danger',
+ 'meeting_report': 'info',
+}
+
+_CONTROL_TYPE_ICON_MAP = {
+ 'control': 'bi-clipboard-check',
+ 'site_report': 'bi-building-gear',
+ 'statement': 'bi-exclamation-octagon',
+ 'meeting_report': 'bi-people',
+}
+
+
+def _get_viewable_controls_queryset(user):
+ """Retourne le queryset des contrôles accessibles pour un utilisateur selon les règles de permissions."""
+ is_admin = bool(
+ getattr(user, "config", None) and
+ (user.config.has_role("admin") or user.config.has_role("top_manager"))
+ )
author_q = Q(control_author=user)
-
-
- # Accès direct au projet
is_member_q = Q(Exists(
ProjectUserAccess.objects.filter(user=user, project=OuterRef('project'), can_view=True)
))
- # Accès thématique (uniquement si user interne) :
- # - contrôles sans projet : accès si thématique correspondante
- # - contrôles avec projet + visibilité 'all' : accès thématique en fallback
if getattr(user, "config", None) and user.config.is_intern:
user_thematic_ids = UserThematics.objects.filter(
user_config=user.config,
can_view_interventions=True
).values_list('thematic_id', flat=True)
- # Un interne peut voir tout contrôle avec thématique correspondante,
- # qu'il soit lié à un projet ou non, dès lors qu'il n'est pas privé
- # (les contrôles privés sont filtrés par not_private_q).
thematic_access_q = Q(thematics__in=user_thematic_ids)
else:
- thematic_access_q = Q(pk__in=[]) # aucun accès thématique
+ thematic_access_q = Q(pk__in=[])
- # Visibilité : exclure les contrôles privés dont l'utilisateur n'est pas l'auteur
not_private_q = ~Q(visibility='private') | author_q
- # Visibilité : exclure les contrôles internes pour les utilisateurs externes
is_intern = getattr(user, "config", None) and user.config.is_intern
if is_intern:
- not_intern_only_q = Q() # les internes peuvent voir les contrôles 'intern'
+ not_intern_only_q = Q()
else:
not_intern_only_q = ~Q(visibility='intern') | author_q
if is_admin:
- controls_qs = Control.objects.all().distinct()
+ controls_qs = Control.objects.all()
else:
controls_qs = Control.objects.filter(
(
author_q
- | (
- # Membre du projet (si projet présent)
- Q(project__isnull=False) & is_member_q
- )
- | thematic_access_q # Accès thématique (avec ou sans projet)
+ | (Q(project__isnull=False) & is_member_q)
+ | thematic_access_q
)
& not_private_q
& not_intern_only_q
- ).distinct()
+ )
- controls_list = []
- for control in controls_qs:
- control_dict = {
- 'id': control.id,
- 'control_code': control.control_code,
- 'description': control.description,
- 'author': control.control_author.username if control.control_author else "",
- 'link': control.get_absolute_url(), # Use get_absolute_url for the link
- #'coordinates': [project.geom_4326.x, project.geom_4326.y] # Extract coordinates from the transformed centroid
+ return controls_qs.distinct()
+
+
+def _apply_control_filters(qs, params, user):
+ """Applique les filtres reçus en paramètres GET au queryset de contrôles."""
+ thematics = params.getlist('thematic')
+ if thematics:
+ qs = qs.filter(thematics__code__in=thematics)
+
+ categories = params.getlist('category')
+ if categories:
+ child_ids = list(AssetCategory.objects.filter(parent_id__in=categories).values_list('id', flat=True))
+ expanded_categories = list(categories) + [str(c) for c in child_ids]
+ qs = qs.filter(categories__id__in=expanded_categories)
+
+ types = params.getlist('type')
+ if types:
+ qs = qs.filter(control_type__in=types)
+
+ statuses = params.getlist('status')
+ if statuses:
+ qs = qs.filter(status__in=statuses)
+
+ projects = params.getlist('project')
+ if projects:
+ qs = qs.filter(project__id__in=projects)
+
+ show_mine_only = params.get('mine') == '1'
+ if show_mine_only:
+ qs = qs.filter(control_author=user)
+
+ date_from = (params.get('date_from') or '').strip()
+ date_to = (params.get('date_to') or '').strip()
+ if date_from:
+ qs = qs.filter(created_at__date__gte=date_from)
+ if date_to:
+ qs = qs.filter(created_at__date__lte=date_to)
+
+ search_query = (params.get('q') or '').strip()
+ search_mode = (params.get('search_mode') or 'and').lower()
+ if search_mode not in ('and', 'or'):
+ search_mode = 'and'
+ if search_query:
+ words = search_query.split()
+ def _word_q(word):
+ return (
+ Q(control_code__icontains=word) |
+ Q(description__icontains=word) |
+ Q(location__icontains=word) |
+ Q(project__name__icontains=word)
+ )
+ combined = Q()
+ if search_mode == 'and':
+ for w in words:
+ combined &= _word_q(w)
+ else:
+ for w in words:
+ combined |= _word_q(w)
+ qs = qs.filter(combined)
+
+ return qs.distinct()
+
+
+@login_required
+def controls_index(request):
+ """Page d'index des contrôles avec vue partagée tableau / carte et filtres."""
+ user = request.user
+ variant = request.GET.get('v', 'desktop')
+ if "/mobile/" in request.path:
+ variant = 'mobile'
+
+ lang = get_language()
+ order_field = f'name_{lang}' if lang == 'nl' else 'name_fr'
+
+ user_config = getattr(request.user, 'config', None)
+ is_admin = bool(user_config and (user_config.has_role("admin") or user_config.has_role("top_manager")))
+
+ if is_admin:
+ thematics = Thematic.objects.all().order_by(order_field)
+ thematic_ids = list(thematics.values_list('id', flat=True))
+ elif user_config and user_config.is_intern:
+ thematic_ids = list(UserThematics.objects.filter(
+ user_config=user_config,
+ can_view_interventions=True
+ ).values_list('thematic_id', flat=True))
+ thematics = Thematic.objects.filter(id__in=thematic_ids).order_by(order_field)
+ else:
+ thematic_ids = []
+ thematics = Thematic.objects.none()
+
+ categories = AssetCategory.objects.filter(thematic__id__in=thematic_ids).order_by(order_field) if thematic_ids else AssetCategory.objects.none()
+ viewable_projects = filter_viewable_projects_for_user(request.user).order_by('name')
+
+ saved_filters = (user_config.control_list_filters or {}) if user_config else {}
+ saved_sort = (user_config.control_list_sort or {}) if user_config else {}
+
+ # Redirect on first visit with saved preferences (desktop only)
+ if variant != 'mobile' and not request.GET and saved_filters:
+ query_params = request.GET.copy()
+ for key, value in saved_filters.items():
+ if isinstance(value, list):
+ query_params.setlist(key, value)
+ elif value is not None:
+ query_params[key] = value
+ return redirect(f"{request.path}?{query_params.urlencode()}")
+
+ selected_thematics = request.GET.getlist('thematic')
+ selected_categories = request.GET.getlist('category')
+ selected_statuses = request.GET.getlist('status')
+ selected_types = request.GET.getlist('type')
+ selected_projects = request.GET.getlist('project')
+ search_query = request.GET.get('q', '')
+ show_mine_only = request.GET.get('mine') == '1'
+ date_from = request.GET.get('date_from', '')
+ date_to = request.GET.get('date_to', '')
+
+ controls_qs = _get_viewable_controls_queryset(user)
+
+ if variant == 'mobile':
+ filtered_qs = _apply_control_filters(controls_qs, request.GET, user).select_related(
+ 'control_author', 'project', 'phase'
+ ).prefetch_related('thematics', 'categories')[:100]
+ context = {
+ 'controls': filtered_qs,
+ 'is_add_control_allowed': user_can_add_control(request.user),
}
- controls_list.append(control_dict)
+ return render(request, 'controls/controls_index_mobile.html', context)
context = {
- 'controls': controls_qs,
- 'controls_list': controls_list, # for javascript usage
+ 'thematic_choices': [(t.code, t.name, t.icon) for t in thematics],
+ 'selected_thematics': selected_thematics,
+ 'category_choices': sorted(
+ [(c.id, c.get_name(), c.thematic.code if c.thematic else '', c.parent_id) for c in categories],
+ key=lambda t: (t[3] if t[3] is not None else t[0], 1 if t[3] is not None else 0, t[1])
+ ),
+ 'selected_categories': selected_categories,
+ 'status_choices': [(k, str(l), _CONTROL_STATUS_BADGE_MAP.get(k, 'secondary')) for k, l in CONTROL_STATUS_CHOICES.items()],
+ 'selected_statuses': selected_statuses,
+ 'control_type_choices': [(k, str(l), _CONTROL_TYPE_BADGE_MAP.get(k, 'secondary'), _CONTROL_TYPE_ICON_MAP.get(k, '')) for k, l in CONTROL_TYPE_CHOICES.items()],
+ 'selected_types': selected_types,
+ 'project_choices': [(p.id, p.name) for p in viewable_projects],
+ 'selected_projects': selected_projects,
+ 'search_query': search_query,
+ 'show_mine_only': show_mine_only,
+ 'date_from': date_from,
+ 'date_to': date_to,
+ 'saved_sort': json.dumps(saved_sort, ensure_ascii=False),
'is_add_control_allowed': user_can_add_control(request.user),
}
-
- template_name = 'controls/controls_index_mobile.html' if variant == 'mobile' else 'controls/controls_index.html'
+ return render(request, 'controls/controls_index.html', context)
- return render(request, template_name, context)
+
+@require_GET
+@login_required
+def controls_geojson(request):
+ """Retourne les contrôles sous forme de GeoJSON FeatureCollection pour la carte et le tableau."""
+ user = request.user
+ qs = _get_viewable_controls_queryset(user).select_related(
+ 'control_author', 'project', 'phase'
+ ).prefetch_related(
+ 'thematics', 'categories', 'remarks'
+ ).annotate(
+ remarks_count=Count('remarks', distinct=True),
+ geom_geojson=AsGeoJSON(Transform('geom', 4326))
+ )
+
+ qs = _apply_control_filters(qs, request.GET, user)
+ qs = qs.order_by('-updated_at')[:5000]
+
+ features = []
+ for ctrl in qs:
+ geometry = None
+ if ctrl.geom_geojson:
+ try:
+ geometry = json.loads(ctrl.geom_geojson)
+ except (json.JSONDecodeError, TypeError):
+ geometry = None
+
+ if not geometry and ctrl.lon is not None and ctrl.lat is not None:
+ try:
+ geometry = {
+ "type": "Point",
+ "coordinates": [float(ctrl.lon), float(ctrl.lat)]
+ }
+ except (ValueError, TypeError):
+ geometry = None
+
+ thematic_names = [t.name for t in ctrl.thematics.all()]
+ thematic_icons = [t.icon for t in ctrl.thematics.all() if t.icon]
+ category_names = [c.get_name() for c in ctrl.categories.all()]
+
+ features.append({
+ "type": "Feature",
+ "id": ctrl.id,
+ "geometry": geometry,
+ "properties": {
+ "id": ctrl.id,
+ "control_code": ctrl.control_code,
+ "description": ctrl.description or "",
+ "location": ctrl.location or "",
+ "status": ctrl.status,
+ "status_label": ctrl.get_status_display(),
+ "status_badge": _CONTROL_STATUS_BADGE_MAP.get(ctrl.status, 'secondary'),
+ "status_color": _CONTROL_STATUS_COLOR_MAP.get(ctrl.status, '#6c757d'),
+ "control_type": ctrl.control_type,
+ "control_type_label": ctrl.get_control_type_display(),
+ "control_type_badge": _CONTROL_TYPE_BADGE_MAP.get(ctrl.control_type, 'secondary'),
+ "thematics": thematic_names,
+ "thematic_names": ", ".join(thematic_names) if thematic_names else "",
+ "thematic_icon": thematic_icons[0] if thematic_icons else "",
+ "category_names": ", ".join(category_names) if category_names else "",
+ "project_id": ctrl.project_id,
+ "project_name": ctrl.project.name if ctrl.project else "",
+ "phase_name": ctrl.phase.name if ctrl.phase else "",
+ "author": get_short_name(ctrl.control_author) if ctrl.control_author else "",
+ "remarks_count": ctrl.remarks_count,
+ "created_at": ctrl.created_at.isoformat() if ctrl.created_at else "",
+ "updated_at": ctrl.updated_at.isoformat() if ctrl.updated_at else "",
+ "visibility": ctrl.visibility,
+ "visibility_label": ctrl.get_visibility_display(),
+ }
+ })
+
+ return JsonResponse({
+ "type": "FeatureCollection",
+ "features": features
+ }, safe=False)
+
+
+@require_GET
+@login_required
+def controls_export_excel(request):
+ """Exporte les contrôles filtrés vers un fichier Excel."""
+ from openpyxl import Workbook
+ from openpyxl.styles import Font, Alignment, PatternFill
+ from openpyxl.utils import get_column_letter
+
+ user = request.user
+ qs = _get_viewable_controls_queryset(user).select_related(
+ 'control_author', 'project', 'phase'
+ ).prefetch_related(
+ 'thematics', 'categories', 'remarks'
+ ).annotate(
+ remarks_count=Count('remarks', distinct=True)
+ )
+
+ qs = _apply_control_filters(qs, request.GET, user)
+ qs = qs.order_by('-updated_at')[:5000]
+
+ wb = Workbook()
+ ws = wb.active
+ ws.title = str(_("Contrôles"))
+
+ headers = [
+ str(_("Code")),
+ str(_("Type")),
+ str(_("Statut")),
+ str(_("Description")),
+ str(_("Localisation")),
+ str(_("Projet")),
+ str(_("Phase")),
+ str(_("Thématiques")),
+ str(_("Catégories")),
+ str(_("Auteur")),
+ str(_("Nb remarques")),
+ str(_("Date de création")),
+ str(_("Dernière mise à jour")),
+ str(_("Longitude")),
+ str(_("Latitude")),
+ ]
+
+ header_font = Font(name="Calibri", size=11, bold=True, color="FFFFFF")
+ header_fill = PatternFill(start_color="2F3E8B", end_color="2F3E8B", fill_type="solid")
+ header_alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
+
+ ws.append(headers)
+
+ for col_num in range(1, len(headers) + 1):
+ cell = ws.cell(row=1, column=col_num)
+ cell.font = header_font
+ cell.fill = header_fill
+ cell.alignment = header_alignment
+
+ for ctrl in qs:
+ thematic_names = ", ".join(t.name for t in ctrl.thematics.all())
+ category_names = ", ".join(c.get_name() for c in ctrl.categories.all())
+ row = [
+ ctrl.control_code,
+ ctrl.get_control_type_display(),
+ ctrl.get_status_display(),
+ ctrl.description or "",
+ ctrl.location or "",
+ ctrl.project.name if ctrl.project else "",
+ ctrl.phase.name if ctrl.phase else "",
+ thematic_names,
+ category_names,
+ get_short_name(ctrl.control_author) if ctrl.control_author else "",
+ ctrl.remarks_count,
+ ctrl.created_at.strftime("%d/%m/%Y %H:%M") if ctrl.created_at else "",
+ ctrl.updated_at.strftime("%d/%m/%Y %H:%M") if ctrl.updated_at else "",
+ ctrl.lon if ctrl.lon is not None else "",
+ ctrl.lat if ctrl.lat is not None else "",
+ ]
+ ws.append(row)
+
+ # Ajustement de la largeur des colonnes
+ for col in ws.columns:
+ max_len = 0
+ col_letter = get_column_letter(col[0].column)
+ for cell in col:
+ val_str = str(cell.value or '')
+ max_len = max(max_len, len(val_str))
+ ws.column_dimensions[col_letter].width = min(max(max_len + 3, 10), 50)
+
+ output = io.BytesIO()
+ wb.save(output)
+ output.seek(0)
+
+ response = HttpResponse(
+ output.getvalue(),
+ content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+ )
+ response["Content-Disposition"] = 'attachment; filename="controles.xlsx"'
+ return response
@control_add_required