territories-dashboard-lib 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

territories_dashboard_lib/website_lib/models.py

@@ -0,0 +1,148 @@
+from django.db import models
+from martor.models import MartorField
+
+from territories_dashboard_lib.commons.models import CommonModel
+from territories_dashboard_lib.website_lib.navigation import (
+    parse_footer_navigation,
+    parse_header_navigation,
+    parse_markdown_link,
+)
+from territories_dashboard_lib.website_lib.static_content import (
+    markdown_content_to_html,
+)
+
+
+class MainConf(CommonModel):
+    title = models.TextField(
+        verbose_name="Titre principal du site", default="Tableau de bord"
+    )
+    entity = models.TextField(
+        verbose_name="Entité qui possède le site",
+        default="",
+        help_text="Renseigner le nom de l'entité au même format que le logo officiel en respectant les mises à la ligne.",
+    )
+    header_navigation = models.TextField(
+        verbose_name="Navigation",
+        help_text="""Navigation du header, mettre les liens au format markdown avec un slash à la fin du lien, mettre une ligne vide entre chaque rubrique. <br/><br/>
+        
+        Une rubrique peut contenir un seul lien, ou bien plusiers, dans ce cas la rubrique sera sous forme de dropdown et il faut mettre un titre en premier. <br/><br/>Par exemple : <br/>
+        <br/><br/>
+        [Accueil](/accueil/)
+        <br/><br/>
+        [Indicateurs territoriaux](/indicateurs/)
+        <br/><br/>
+        À propos
+        [Présentation](/presentation/)
+        [Journal des versions](/journal/)
+        """,
+        default="",
+    )
+    footer_navigation = models.TextField(
+        verbose_name="Navigation",
+        help_text="""Navigation du footer, mettre les liens au format markdown, un par ligne. <br/><br/>
+    Si le lien est interne, commencer et terminer le lien par un slash comme "/accueil/"<br/><br/>
+    Par exemple : <br/><br/>
+    [Plan du site](/plan-site/)<br/>
+    [Accessibilité](/accessibilite/)<br/>
+    [Mentions légales](/mentions-legales/) <br/>
+    """,
+        default="",
+    )
+
+    @property
+    def entity_breaklines(self):
+        return self.entity.replace("\n", "<br/>")
+
+    @property
+    def parsed_header_navigation(self):
+        return parse_header_navigation(self.header_navigation)
+
+    @property
+    def parsed_footer_navigation(self):
+        return parse_footer_navigation(self.footer_navigation)
+
+    def __str__(self):
+        return "Configuration principale"
+
+    class Meta:
+        verbose_name = "Configuration principale"
+        verbose_name_plural = "Configurations principales"
+
+
+class LandingPage(CommonModel):
+    title = models.TextField(verbose_name="Titre")
+    body = MartorField(verbose_name="Contenu")
+    button_link = models.TextField(
+        verbose_name="Lien du bouton",
+        help_text="Au format markdown, par exemple : <br/><br/>[découvrir les indicateurs](/indicateurs/)",
+    )
+
+    @property
+    def body_html(self):
+        return markdown_content_to_html(self.body)
+
+    @property
+    def button(self):
+        return parse_markdown_link(self.button_link)
+
+    class Meta:
+        verbose_name = "Page d'accueil"
+        verbose_name_plural = "Page d'accueil"
+
+    def __str__(self):
+        return "Page d'accueil"
+
+
+class StaticPage(CommonModel):
+    name = models.TextField(verbose_name="Nom de la page")
+    url = models.TextField(
+        verbose_name="Url de la page",
+        help_text="En minuscule avec des espaces remplacés par des traits '-'.<br/>Par exemple : <br/><br/> indicateurs <br/> mentions-legales",
+    )
+    body = MartorField(verbose_name="Contenu")
+
+    @property
+    def body_html(self):
+        return markdown_content_to_html(self.body)
+
+    class Meta:
+        verbose_name = "Page Statique"
+        verbose_name_plural = "Pages Statiques"
+
+    def __str__(self):
+        return self.name
+
+
+class GlossaryItem(CommonModel):
+    word = models.TextField(verbose_name="Mot")
+    definition = models.TextField(verbose_name="Définition")
+
+    class Meta:
+        verbose_name = "Définition"
+        verbose_name_plural = "Page Lexique"
+        ordering = ["word"]
+
+    def __str__(self):
+        return self.word
+
+
+class NoticeBanner(CommonModel):
+    title = models.CharField(max_length=64, verbose_name="Titre")
+    description = models.CharField(max_length=255, verbose_name="Description")
+    link_href = models.CharField(
+        null=True,
+        blank=True,
+        max_length=255,
+        verbose_name="Lien",
+        help_text="Le lien doit être un lien interne et commencer et terminer par '/', par exemple '/journal/",
+    )
+    link_text = models.CharField(
+        null=True,
+        blank=True,
+        max_length=64,
+        verbose_name="Intitulé du lien",
+        help_text="à remplir seulement si un lien est spécifié",
+    )
+
+    class Meta:
+        ordering = ["-created_at"]

territories_dashboard_lib/website_lib/navigation.py

@@ -0,0 +1,124 @@
+import re
+
+from django.apps import apps
+from django.urls import reverse
+
+
+def parse_header_navigation(header_navigation):
+    """
+    Retourne une liste de sections. Chaque section est soit :
+    - {'title': 'Accueil', 'link': '/accueil/'}
+    - {'title': 'À propos', 'links': [{'title': 'Présentation', 'link': '/presentation/'}]}
+    """
+    menu = []
+
+    # Découpage robuste en blocs (rubriques), même s'il y a des \r, espaces, etc.
+    blocks = re.split(r"\n\s*\n", header_navigation.strip())
+
+    for block in blocks:
+        lines = [line.strip() for line in block.strip().splitlines() if line.strip()]
+        if not lines:
+            continue
+
+        title = None
+        links = []
+
+        # Si la première ligne n’est pas un lien markdown, c’est le titre
+        first_line = lines[0]
+        match = re.match(r"\[(.+?)\]\((/.+?/)\)", first_line)
+        if match:
+            # Bloc sans titre
+            links.append(
+                {
+                    "title": match.group(1).strip(),
+                    "link": match.group(2).strip(),
+                }
+            )
+            other_lines = lines[1:]
+        else:
+            # cas spécial superset
+            if first_line == "superset":
+                Dashboard = apps.get_model("superset_lib", "Dashboard")
+                links = [
+                    {
+                        "title": d.label,
+                        "link": reverse(
+                            "website:superset", kwargs={"dashboard_name": d.short_name}
+                        )
+                        + "#header-navigation",
+                    }
+                    for d in Dashboard.objects.all().order_by("order")
+                ]
+                menu.append({"title": "Portraits de territoires", "links": links})
+                continue
+            # La première ligne est le titre
+            title = first_line
+            other_lines = lines[1:]
+
+        # Parse les lignes suivantes comme liens
+        for line in other_lines:
+            match = re.match(r"\[(.+?)\]\((/.+?/)\)", line)
+            if not match:
+                raise ValueError(
+                    f"La ligne « {line} » n’est pas un lien valide Markdown."
+                )
+            links.append(
+                {
+                    "title": match.group(1).strip(),
+                    "link": match.group(2).strip(),
+                }
+            )
+
+        # Construction finale
+        if title:
+            if not links:
+                raise ValueError(f"La rubrique « {title} » ne contient aucun lien.")
+            menu.append({"title": title, "links": links})
+        elif len(links) == 1:
+            menu.append(links[0])
+        else:
+            raise ValueError("Un groupe de plusieurs liens doit avoir un titre.")
+    return menu
+
+
+def parse_footer_navigation(footer_navigation):
+    """
+    Retourne une liste de liens : chacun est un dict avec :
+    - title : texte à afficher
+    - href : URL du lien
+    - is_external : True/False
+    """
+    links = []
+    for line in footer_navigation.strip().splitlines():
+        line = line.strip()
+        if not line:
+            continue
+
+        match = re.match(r"\[(.+?)\]\((.+?)\)", line)
+        if not match:
+            raise ValueError(f"Ligne invalide dans le footer : « {line} »")
+
+        title, href = match.group(1).strip(), match.group(2).strip()
+
+        is_external = href.startswith("http")
+        links.append(
+            {
+                "title": title,
+                "href": href,
+                "is_external": is_external,
+            }
+        )
+    return links
+
+
+def parse_markdown_link(text):
+    text = text.strip()
+    if not text:
+        raise ValueError("Le lien est invalide (vide)")
+
+    match = re.match(r"\[(.+?)\]\((.+?)\)", text)
+    if not match:
+        raise ValueError(f"Ligne invalide dans le footer : « {text} »")
+
+    title, href = match.group(1).strip(), match.group(2).strip()
+    return {"title": title, "href": href}

territories_dashboard_lib/website_lib/params.py

@@ -0,0 +1,268 @@
+from functools import wraps
+
+from territories_dashboard_lib.indicators_lib.enums import (
+    FRANCE_GEOLEVEL_TITLES,
+    MESH_TITLES,
+    FranceGeoLevel,
+    MeshLevel,
+)
+from territories_dashboard_lib.indicators_lib.query.utils import run_custom_query
+
+TERRITORY_DEFAULT = {
+    "id": FranceGeoLevel.METRO,
+    "mesh": MeshLevel.National,
+    "name": FRANCE_GEOLEVEL_TITLES[FranceGeoLevel.METRO],
+}
+
+CMP_TERRITORY_DEFAULT = {
+    "id": FranceGeoLevel.All,
+    "mesh": MeshLevel.National,
+    "name": FRANCE_GEOLEVEL_TITLES[FranceGeoLevel.All],
+}
+
+TERRITORY_PARAM_NAME = "territory"
+CMP_TERRITORY_PARAM_NAME = "cmp-territory"
+MESH_PARAM_NAME = "mesh"
+ONE_WEEK_IN_SECONDS = 604800
+
+
+class BadParam(Exception):
+    pass
+
+
+class ParamsHandler:
+    def __init__(self, request):
+        self.request = request
+        self.territory_id = None
+        self.territory_mesh = None
+        self.territory_name = None
+        self.cmp_territory_id = None
+        self.cmp_territory_mesh = None
+        self.cmp_territory_name = None
+        self.mesh = None
+        self.meshes = []
+        self.comparison = request.resolver_match.view_name == "website:comparison"
+
+    ######################## Territory
+
+    def parse_territory(self, territory):
+        if not territory:
+            raise BadParam
+        parts = territory.split("-")
+        allowed_chars = set(
+            "0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz, "
+        )
+        if (
+            len(parts) != 2
+            or not all(char in allowed_chars for char in parts[0])
+            or parts[1] not in MeshLevel
+        ):
+            raise BadParam
+        return parts[0], parts[1]
+
+    def get_territory_name(self, territory_id, territory_mesh):
+        if territory_mesh == MeshLevel.National:
+            return FRANCE_GEOLEVEL_TITLES[territory_id]
+        mesh = "DEPCOM" if territory_mesh == "com" else territory_mesh.upper()
+        query = f"""
+        SELECT DISTINCT "NOM_{mesh}" AS name FROM arborescence_geo
+        WHERE "{mesh}" = '{territory_id}'
+        """
+        try:
+            results = run_custom_query(query)
+        except Exception:
+            raise BadParam
+        if not results:
+            raise BadParam
+        return results[0]["name"]
+
+    def get_territory_default(self, cookie_territory):
+        try:
+            territory_id, territory_mesh = self.parse_territory(cookie_territory)
+            territory_name = self.get_territory_name(territory_id, territory_mesh)
+        except BadParam:
+            return (
+                TERRITORY_DEFAULT["id"],
+                TERRITORY_DEFAULT["mesh"],
+                TERRITORY_DEFAULT["name"],
+            )
+        return territory_id, territory_mesh, territory_name
+
+    def choose_territory(self):
+        url_territory = self.request.GET.get(TERRITORY_PARAM_NAME)
+        try:
+            territory_id, territory_mesh = self.parse_territory(url_territory)
+            self.territory_name = self.get_territory_name(territory_id, territory_mesh)
+            self.territory_id = territory_id
+            self.territory_mesh = territory_mesh
+        except BadParam:
+            cookie_territory = self.request.COOKIES.get(TERRITORY_PARAM_NAME)
+            self.territory_id, self.territory_mesh, self.territory_name = (
+                self.get_territory_default(cookie_territory)
+            )
+
+    def construct_territory_value(self):
+        return f"{self.territory_id}-{self.territory_mesh}"
+
+    def territory_is_not_default(self):
+        return (
+            self.territory_id != TERRITORY_DEFAULT["id"]
+            or self.territory_mesh != TERRITORY_DEFAULT["mesh"]
+        )
+
+    ######################## Compared Territory
+
+    def choose_cmp_territory(self):
+        url_territory = self.request.GET.get(CMP_TERRITORY_PARAM_NAME)
+        try:
+            territory_id, territory_mesh = self.parse_territory(url_territory)
+            self.cmp_territory_name = self.get_territory_name(
+                territory_id, territory_mesh
+            )
+            self.cmp_territory_id = territory_id
+            self.cmp_territory_mesh = territory_mesh
+        except BadParam:
+            cookie_territory = self.request.COOKIES.get(CMP_TERRITORY_PARAM_NAME)
+            self.cmp_territory_id, self.cmp_territory_mesh, self.cmp_territory_name = (
+                self.get_territory_default(cookie_territory)
+            )
+
+    def construct_cmp_territory_value(self):
+        return f"{self.cmp_territory_id}-{self.cmp_territory_mesh}"
+
+    def cmp_territory_is_not_default(self):
+        return (
+            self.cmp_territory_id != CMP_TERRITORY_DEFAULT["id"]
+            or self.cmp_territory_mesh != CMP_TERRITORY_DEFAULT["mesh"]
+        )
+
+    ######################## Mesh
+
+    def get_max_territory_mesh(self):
+        meshes = [m for m in MeshLevel]
+        if self.comparison is False:
+            return self.territory_mesh
+        if meshes.index(self.cmp_territory_mesh) > meshes.index(self.territory_mesh):
+            return self.cmp_territory_mesh
+        return self.territory_mesh
+
+    def is_not_valid_mesh(self, mesh):
+        if mesh is None:
+            return True
+        meshes = [m for m in MeshLevel]
+        max_territory_mesh = self.get_max_territory_mesh()
+        is_not_valid = meshes.index(max_territory_mesh) >= meshes.index(mesh)
+        return is_not_valid
+
+    def get_default_mesh(self):
+        max_territory_mesh = self.get_max_territory_mesh()
+        meshes = [m for m in MeshLevel]
+        if meshes.index(max_territory_mesh) == len(meshes) - 1:
+            default_mesh = meshes[-1]
+        else:
+            default_mesh = meshes[meshes.index(max_territory_mesh) + 1]
+        return default_mesh
+
+    def get_cookie_mesh(self):
+        value = self.request.COOKIES.get(MESH_PARAM_NAME)
+        if not value:
+            return None
+        parts = value.split("-")
+        if len(parts) != 2 or parts[0] not in MeshLevel or parts[1] not in MeshLevel:
+            return None
+        if self.territory_mesh != parts[0]:
+            return None
+        return parts[1]
+
+    def choose_mesh(self):
+        url_mesh = self.request.GET.get(MESH_PARAM_NAME)
+        url_mesh = url_mesh if url_mesh in MeshLevel else None
+        if self.is_not_valid_mesh(url_mesh):
+            cookie_mesh = self.get_cookie_mesh()
+            if self.is_not_valid_mesh(cookie_mesh):
+                self.mesh = self.get_default_mesh()
+            else:
+                self.mesh = cookie_mesh
+        else:
+            self.mesh = url_mesh
+        max_territory_mesh = self.get_max_territory_mesh()
+        meshes = [
+            m
+            for m in MeshLevel
+            if not (m == MeshLevel.Town and max_territory_mesh == MeshLevel.National)
+        ]
+        self.meshes = meshes[
+            min(meshes.index(max_territory_mesh) + 1, len(meshes) - 1) :
+        ]
+
+    ######################## Commons
+
+    def set_cookie(self, response):
+        if self.territory_is_not_default():
+            response.set_cookie(
+                key=TERRITORY_PARAM_NAME,
+                value=self.construct_territory_value(),
+                max_age=ONE_WEEK_IN_SECONDS,
+            )
+        else:
+            response.delete_cookie(TERRITORY_PARAM_NAME)
+        if self.cmp_territory_is_not_default():
+            response.set_cookie(
+                key=CMP_TERRITORY_PARAM_NAME,
+                value=self.construct_cmp_territory_value(),
+                max_age=ONE_WEEK_IN_SECONDS,
+            )
+        else:
+            response.delete_cookie(CMP_TERRITORY_PARAM_NAME)
+        if self.mesh != self.get_default_mesh():
+            response.set_cookie(
+                key=MESH_PARAM_NAME,
+                value=f"{self.territory_mesh}-{self.mesh}",
+                max_age=ONE_WEEK_IN_SECONDS,
+            )
+        else:
+            response.delete_cookie(MESH_PARAM_NAME)
+
+    def add_to_context(self, context):
+        url_params = []
+        if self.territory_is_not_default():
+            url_params.append(
+                f"{TERRITORY_PARAM_NAME}={self.construct_territory_value()}"
+            )
+        if self.comparison and self.cmp_territory_is_not_default():
+            url_params.append(
+                f"{CMP_TERRITORY_PARAM_NAME}={self.construct_cmp_territory_value()}"
+            )
+        if self.mesh != self.get_default_mesh():
+            url_params.append(f"{MESH_PARAM_NAME}={self.mesh}")
+        context["params"] = {
+            "territory_id": self.territory_id,
+            "territory_mesh": self.territory_mesh,
+            "territory_name": self.territory_name,
+            "cmp_territory_id": self.cmp_territory_id,
+            "cmp_territory_mesh": self.cmp_territory_mesh,
+            "cmp_territory_name": self.cmp_territory_name,
+            "mesh": self.mesh,
+            "meshes": self.meshes,
+            "meshes_titles": MESH_TITLES,
+            "all_meshes": [m for m in MeshLevel],
+            "url_params": "&".join(url_params),
+        }
+
+
+def with_params(view_func):
+    @wraps(view_func)
+    def wrapper(request, *args, **kwargs):
+        handler = ParamsHandler(request)
+        handler.choose_territory()
+        handler.choose_cmp_territory()
+        handler.choose_mesh()
+
+        context = kwargs.get("context", {})
+        handler.add_to_context(context)
+
+        response = view_func(request, *args, context=context, **kwargs)
+        handler.set_cookie(response)
+        return response
+
+    return wrapper

territories_dashboard_lib/website_lib/serializers.py

@@ -0,0 +1,105 @@
+from django.db.models import Count, Q
+from martor.utils import markdownify
+
+
+def serialize_indicator(indicator):
+    return {
+        "id": indicator.id,
+        "name": indicator.name,
+        "title": indicator.title,
+        "description": indicator.description,
+        "source": indicator.source,
+        "unite": indicator.unite,
+        "unite_nom_accessible": indicator.unite_nom_accessible,
+        "unite_alternative": indicator.unite_alternative,
+        "unite_alternative_nom_accessible": indicator.unite_alternative_nom_accessible,
+        "show_alternative": indicator.show_alternative,
+        "methodo_html": markdownify(indicator.methodo),
+        "db_table_prefix": indicator.db_table_prefix,
+        "is_composite": indicator.is_composite,
+        "aggregation_constant": indicator.aggregation_constant,
+        "flows_db_table_prefix": indicator.flows_db_table_prefix,
+        "flows_dimension": indicator.flows_dimension,
+        "theme": indicator.sub_theme.theme.title,
+        "filters": serializer_filters(indicator),
+        "secondary_indicator": {
+            "name": indicator.secondary_indicator.name,
+            "title": indicator.secondary_indicator.title,
+            "aggregation_constant": indicator.secondary_indicator.aggregation_constant,
+            "db_table_prefix": indicator.secondary_indicator.db_table_prefix,
+            "unite": indicator.secondary_indicator.unite,
+            "unite_alternative": indicator.secondary_indicator.unite_alternative,
+            "is_composite": indicator.secondary_indicator.is_composite,
+            "filters": serializer_filters(indicator.secondary_indicator),
+        }
+        if indicator.secondary_indicator
+        else None,
+        "geo_features": [
+            {
+                "id": gf.id,
+                "name": gf.name,
+                "title": gf.title,
+                "unite": gf.unite,
+                "geo_type": gf.geo_type,
+                "point_icon_svg": gf.point_icon_svg,
+                "color": gf.color,
+                "show_on_fr_level": gf.show_on_fr_level,
+                "items": [
+                    {
+                        "name": item.name,
+                        "label": item.label,
+                        "filterable": item.filterable,
+                    }
+                    for item in gf.items.all()
+                ],
+            }
+            for gf in indicator.geo_features.all()
+        ],
+    }
+
+
+def serializer_filters(indicator):
+    return [
+        (
+            {
+                "db_name": dimension.db_name,
+                "title": dimension.title,
+                "is_breakdown": dimension.is_breakdown,
+            },
+            [
+                {
+                    "db_name": filtr.db_name,
+                    "default": filtr.default,
+                }
+                for filtr in dimension.filters.all()
+            ],
+        )
+        for dimension in indicator.dimensions.all()
+    ]
+
+
+def serialize_sub_themes(theme):
+    sub_themes = (
+        theme.sub_themes.all()
+        .annotate(
+            active_indicators_count=Count(
+                "indicators", filter=Q(indicators__is_active=True)
+            )
+        )
+        .filter(active_indicators_count__gt=0)
+        .order_by("index_in_theme")
+    )
+    sub_themes = [
+        {
+            "name": sub_theme.name,
+            "title": sub_theme.title,
+            "indicators": [
+                serialize_indicator(indicator)
+                for indicator in sub_theme.indicators.filter(is_active=True).order_by(
+                    "index_in_theme"
+                )
+            ],
+        }
+        for sub_theme in sub_themes
+    ]
+    return sub_themes