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

territories_dashboard_lib/indicators_lib/query/commons.py

@@ -0,0 +1,223 @@
+from ..enums import DEFAULT_MESH, FRANCE_DB_VALUES, GeoLevel, MeshLevel
+from ..models import AggregationFunctions, Indicator
+from .utils import get_breakdown_dimension, run_custom_query
+
+
+def get_last_year(indicator, mesh):
+    query = f""" SELECT MAX(annee) as last_year FROM "{indicator.db_table_prefix}_{mesh}" """
+    return run_custom_query(query)[0]["last_year"]
+
+
+def generate_aggregate_query(indicator, territory, submesh, filters, slicer):
+    query = f"""
+    WITH annee_max AS
+    (SELECT MAX(annee) FROM "{indicator.db_table_prefix}_{submesh}"),
+    aggregat AS
+    (
+        SELECT
+        {calculate_aggregate_values(indicator)}, {slicer}
+        FROM
+        {get_table_data_for_geography(indicator, territory, submesh)}
+        {add_optional_filters(indicator, filters)}
+        AND annee = (SELECT * FROM annee_max)
+        GROUP BY (indic.{slicer})
+    )
+    """
+    return query
+
+
+def generate_aggregate_query_for_location(indicator, territory, submesh, filters):
+    return generate_aggregate_query(
+        indicator, territory, submesh, filters, f"code_{submesh}"
+    )
+
+
+def add_optional_filters(indicator: Indicator, filters):
+    condition = ""
+    all_dimensions = [dimension.db_name for dimension in indicator.dimensions.all()]
+    for dimension in all_dimensions:
+        if filters and filters.get(dimension):
+            filters_str = ", ".join(
+                [f"'{value.replace("'", "''")}'" for value in filters.get(dimension)]
+            )
+            condition += f' AND indic."{dimension}" in ({filters_str}) '
+    return condition
+
+
+def get_place_names_join(include_place_name, mapped_submesh, submesh, flows=False):
+    join_clause = ""
+    if include_place_name:
+        if flows:
+            join_clause = f"""
+            JOIN
+                (SELECT distinct("NOM_{mapped_submesh}") as territory_1, "{mapped_submesh}" as territory_1_id, "{mapped_submesh}" from arborescence_geo) arbo1
+                on arbo1."{mapped_submesh}" = indic.code_{submesh.lower()}_1
+            JOIN
+                (SELECT distinct("NOM_{mapped_submesh}") as territory_2, "{mapped_submesh}" as territory_2_id, "{mapped_submesh}" from arborescence_geo) arbo2
+                on arbo2."{mapped_submesh}" = indic.code_{submesh.lower()}_2
+            """
+        else:
+            join_clause = f"""
+                JOIN
+                (SELECT distinct("NOM_{mapped_submesh}") as lieu, "{mapped_submesh}" as territoryid, "{mapped_submesh}" from arborescence_geo) arbo
+                on arbo."{mapped_submesh}" = indic.code_{submesh.lower()}
+            """
+    return join_clause
+
+
+def get_table_data_for_geography(
+    indicator,
+    territory,
+    submesh=MeshLevel.Region,
+    include_place_names=None,
+    flows=False,
+):
+    mapped_mesh = "DEPCOM" if territory.mesh == "com" else territory.mesh.upper()
+    mapped_submesh = "DEPCOM" if submesh == "com" else submesh.upper()
+
+    geo_id_values = "', '".join([id.strip() for id in territory.id.split(",")])
+
+    table_prefix = (
+        indicator.flows_db_table_prefix if flows else indicator.db_table_prefix
+    )
+
+    arbo_sub_query = f"""
+    SELECT DISTINCT("{mapped_submesh}")
+    FROM arborescence_geo arbo
+    WHERE arbo."{mapped_mesh}" in('{geo_id_values}')
+    """
+
+    where = (
+        f"""
+        WHERE (indic.code_{submesh.lower()}_1 in ({arbo_sub_query})
+        OR indic.code_{submesh.lower()}_2 in ({arbo_sub_query}))
+        """
+        if flows
+        else f"""
+        WHERE indic.code_{submesh.lower()} in ({arbo_sub_query})
+        """
+    )
+
+    return f"""
+    "{table_prefix}_{submesh.lower()}" indic
+    {get_place_names_join(include_place_names, mapped_submesh, submesh, flows)}
+    {where}
+    """
+
+
+def calculate_aggregate_values(indicator, with_alternative=True):
+    if not indicator.is_composite:
+        return "SUM(valeur) as valeur"
+
+    if indicator.aggregation_function == AggregationFunctions.DISCRETE_COMPONENT_2:
+        sql = f"SUM(composante_1) / COALESCE(NULLIF(SUM(composante_2), 0), 1) * {indicator.aggregation_constant} as valeur"
+        if with_alternative:
+            sql += ", SUM(composante_1) as valeur_alternative"
+        return sql
+    breakdown_dimension = get_breakdown_dimension(indicator)
+    breakdown_count = (
+        f" * COUNT(DISTINCT({breakdown_dimension.db_name})) "
+        if breakdown_dimension
+        else ""
+    )
+    sql = f"SUM(composante_1) / COALESCE(NULLIF(SUM(composante_2), 0), 1) {breakdown_count} * {indicator.aggregation_constant} as valeur"
+    if with_alternative:
+        sql += ", SUM(composante_1) as valeur_alternative"
+    return sql
+
+
+def order_filters(filters, bo_ordered_filters):
+    # Filters that exist in the predefined order
+    ordered_filters = [filter for filter in bo_ordered_filters if filter in filters]
+
+    # Filters that are not in the predefined order, sorted alphabetically
+    not_in_bo = sorted(
+        [item for item in filters if item not in bo_ordered_filters],
+        key=lambda x: x.lower(),  # Case-insensitive alphabetical sort
+    )
+
+    # Combine both lists
+    final_array = ordered_filters + not_in_bo
+    return final_array
+
+
+def get_mesh_level_for_geo_level(mesh, submesh):
+    if mesh == GeoLevel.Region:
+        return (
+            MeshLevel.Department
+            if submesh is None or submesh in [MeshLevel.National, MeshLevel.Region]
+            else submesh
+        )
+    elif mesh == GeoLevel.Department:
+        return (
+            MeshLevel.Epci
+            if submesh is None
+            or submesh in [MeshLevel.National, MeshLevel.Region, MeshLevel.Department]
+            else submesh
+        )
+    elif mesh in [GeoLevel.Epci, GeoLevel.Town]:
+        return MeshLevel.Town
+    else:
+        return submesh or DEFAULT_MESH
+
+
+def get_territories_ids(main_territory_codes, territory_mesh, submesh):
+    mapped_territory_mesh = (
+        "DEPCOM" if territory_mesh == "com" else territory_mesh.upper()
+    )
+    mapped_submesh = "DEPCOM" if submesh == "com" else submesh.upper()
+
+    query = f"""
+        SELECT DISTINCT "{mapped_submesh}" as code
+        FROM arborescence_geo
+        WHERE "{mapped_territory_mesh}" IN ('{"', '".join(main_territory_codes)}')
+        """
+
+    territories_ids = [r["code"] for r in run_custom_query(query)]
+    return territories_ids
+
+
+def get_sub_territories(territory, submesh):
+    territory_codes = territory.id.split(",")
+    mapped_territory_mesh = (
+        "DEPCOM" if territory.mesh == "com" else territory.mesh.upper()
+    )
+    mapped_submesh = "DEPCOM" if submesh == "com" else submesh.upper()
+
+    query = f"""
+        SELECT DISTINCT "{mapped_submesh}" as code, "NOM_{mapped_submesh}" as name
+        FROM arborescence_geo
+        WHERE "{mapped_territory_mesh}" IN ('{"', '".join(territory_codes)}')
+        """
+
+    return run_custom_query(query)
+
+
+def get_where_territory(territory):
+    territory_id = (
+        FRANCE_DB_VALUES[territory.id]
+        if territory.mesh == MeshLevel.National
+        else territory.id
+    )
+    return f""" "code_{territory.mesh}" = '{territory_id}' """
+
+
+def get_values_for_territory(indicator, territory, filters=None):
+    value = calculate_aggregate_values(indicator)
+    where_territory = get_where_territory(territory)
+    query = f"""
+        SELECT {value}, annee
+        FROM "{indicator.db_table_prefix}_{territory.mesh}" as indic
+        WHERE {where_territory}
+        {add_optional_filters(indicator, filters)}
+        GROUP BY annee
+        ORDER BY annee DESC
+    """
+    return query
+
+
+def get_territory_name(territory):
+    territory_mesh = "DEPCOM" if territory.mesh == "com" else territory.mesh.upper()
+    query = f"""SELECT "NOM_{territory_mesh}" as nom FROM arborescence_geo WHERE "{territory_mesh}" = '{territory.id}' LIMIT 1;"""
+    results = run_custom_query(query)
+    return results[0]["nom"] if results else ""

territories_dashboard_lib/indicators_lib/query/comparison.py

@@ -0,0 +1,70 @@
+from collections import defaultdict
+
+from .commons import add_optional_filters, calculate_aggregate_values
+from .utils import run_custom_query
+
+
+def get_comparison_values_and_buckets(
+    indicator, submesh, territories, cmp_territories, filters
+):
+    territories_ids = [t["code"] for t in territories + cmp_territories]
+    territories_sql = f"('{"', '".join(territories_ids)}')"
+    table_name = f"{indicator.db_table_prefix}_{submesh}"
+    filters = add_optional_filters(indicator, filters)
+    value = calculate_aggregate_values(indicator, with_alternative=False)
+    number_of_buckets = min(10, len(territories) + len(cmp_territories))
+    sub_query = f"""
+    SELECT
+        {value},
+        code_{submesh} as geo_code
+    FROM {table_name} indic
+    WHERE code_{submesh} IN {territories_sql}
+    AND annee = (
+        SELECT MAX(annee)
+        FROM {table_name}
+    )
+    AND valeur IS NOT NULL
+    {filters}
+    GROUP BY geo_code
+    """
+    query = f"""
+    WITH aggregated_data AS ({sub_query}),
+    range_bounds AS (
+        SELECT
+            MIN(valeur) - 1e-10 AS min_value,
+            MAX(valeur) + 1e-10 AS max_value
+        FROM aggregated_data
+    )
+    SELECT
+        aggregated_data.valeur,
+        aggregated_data.geo_code,
+        WIDTH_BUCKET(aggregated_data.valeur, range_bounds.min_value, range_bounds.max_value, {number_of_buckets}) AS bucket
+    FROM aggregated_data
+    CROSS JOIN
+        range_bounds
+    """
+    results = run_custom_query(query)
+    raw_values = [r["valeur"] for r in results]
+    min_value = min(raw_values)
+    max_value = max(raw_values)
+    bucket_width = (max_value - min_value) / number_of_buckets
+    buckets = []
+    bucket_min = min_value
+    for i in range(1, number_of_buckets + 1):
+        bucket_max = (
+            max_value if i == number_of_buckets else min_value + i * bucket_width
+        )
+        buckets.append([bucket_min, bucket_max])
+        bucket_min = bucket_max
+    values = defaultdict(list)
+    cmp_values = defaultdict(list)
+    territories_ids_set = {t["code"] for t in territories}
+    cmp_territories_ids_set = {t["code"] for t in cmp_territories}
+    territories_dict = {t["code"]: t["name"] for t in territories + cmp_territories}
+    for r in results:
+        geo_code = r["geo_code"]
+        if geo_code in territories_ids_set:
+            values[r["bucket"]].append(territories_dict[geo_code])
+        if geo_code in cmp_territories_ids_set:
+            cmp_values[r["bucket"]].append(territories_dict[geo_code])
+    return values, cmp_values, buckets

territories_dashboard_lib/indicators_lib/query/details.py

@@ -0,0 +1,64 @@
+from ..enums import MeshLevel
+from ..models import Indicator
+from ..payloads import Territory
+from .commons import (
+    add_optional_filters,
+    calculate_aggregate_values,
+    get_last_year,
+    get_place_names_join,
+    get_where_territory,
+)
+from .utils import get_breakdown_dimension, run_custom_query
+
+
+def get_proportions_chart(indicator, territory, filters):
+    where_territory = get_where_territory(territory)
+    last_year = get_last_year(indicator, territory.mesh)
+    breakdown_dimension = get_breakdown_dimension(indicator).db_name
+
+    query = f"""
+    SELECT {calculate_aggregate_values(indicator, with_alternative=False)}, "{breakdown_dimension}" as dimension
+    FROM "{indicator.db_table_prefix}_{territory.mesh}" as indic
+    WHERE {where_territory} AND annee = {last_year}
+    {add_optional_filters(indicator, filters)}
+    GROUP BY "{breakdown_dimension}"
+"""
+
+    data = run_custom_query(query)
+    data_dict = {
+        d["dimension"]: {"label": d["dimension"], "data": [d["valeur"]]} for d in data
+    }
+    breakdown_filters = filters[breakdown_dimension]
+    sorted_data = (
+        [data_dict[filter] for filter in breakdown_filters if filter in data_dict]
+        if filters
+        else list(data_dict.values())
+    )
+    return sorted_data
+
+
+def get_values_for_submesh_territories(
+    indicator: Indicator, submesh: MeshLevel, territory: Territory, filters
+):
+    submesh = submesh.lower()
+    territory_mesh = "DEPCOM" if territory.mesh == "com" else territory.mesh.upper()
+    mapped_submesh = "DEPCOM" if submesh == "com" else submesh.upper()
+
+    geo_ids = "', '".join([id.strip() for id in territory.id.split(",")])
+    query = f"""
+    SELECT {calculate_aggregate_values(indicator)}, code_{submesh} as geocode, arbo.lieu as geoname
+    FROM "{indicator.db_table_prefix}_{submesh}" indic
+    {get_place_names_join(True, mapped_submesh, submesh)}
+    WHERE code_{submesh} IN (
+        SELECT DISTINCT("{mapped_submesh}")
+        FROM arborescence_geo arbo
+        WHERE arbo."{territory_mesh}" IN ('{geo_ids}')
+    )
+    {add_optional_filters(indicator, filters)}
+    AND annee = (
+        SELECT MAX(annee)
+        FROM "{indicator.db_table_prefix}_{submesh}"
+    )
+    GROUP BY geocode, geoname
+    """
+    return run_custom_query(query)

territories_dashboard_lib/indicators_lib/query/histogram.py

@@ -0,0 +1,82 @@
+from .details import get_values_for_submesh_territories
+
+
+def get_territories_histogram_data(territory_values, unite):
+    if all([t["valeur"] is None for t in territory_values]):
+        return ({}, [])
+    values_for_min_max = [
+        data["valeur"] for data in territory_values if data["valeur"] is not None
+    ]
+    min_value_last_year = min(values_for_min_max) if values_for_min_max else 0
+    max_value_last_year = max(values_for_min_max) if values_for_min_max else 0
+
+    # if we are between 99.5 and 100.5, spread histogram for better visualization
+    if 99.5 < min_value_last_year < 100.5 and 99.5 < max_value_last_year < 100.5:
+        min_value_last_year = 90
+
+    histogram_values_dict = {}
+    for territory_data in territory_values:
+        territory_id = territory_data["geocode"]
+        if territory_id not in histogram_values_dict:
+            histogram_values_dict[territory_id] = {
+                "valeur": 0,
+                "geoname": territory_data["geoname"],
+            }
+        histogram_values_dict[territory_id]["valeur"] += (
+            territory_data["valeur"] if territory_data["valeur"] is not None else 0
+        )
+    histogram_values = list(histogram_values_dict.values())
+
+    deciles = [
+        min_value_last_year + (max_value_last_year - min_value_last_year) * (i / 10)
+        for i in range(10 if min_value_last_year != max_value_last_year else 1)
+    ]
+
+    data_by_decile = [
+        {
+            "decile": decile,
+            "count": len(
+                [
+                    data
+                    for data in histogram_values
+                    if decile
+                    <= data["valeur"]
+                    <= (deciles[i + 1] if i < len(deciles) - 1 else max_value_last_year)
+                ]
+            ),
+            "text": "\n".join(
+                [
+                    data["geoname"]
+                    for data in histogram_values
+                    if decile
+                    <= data["valeur"]
+                    <= (deciles[i + 1] if i < len(deciles) - 1 else max_value_last_year)
+                ]
+            ),
+        }
+        for i, decile in enumerate(deciles)
+    ]
+
+    datasets_histogram_bar_chart = {
+        "label": unite,
+        "data": [{"x": data["decile"], "y": data["count"]} for data in data_by_decile],
+        "comments": [data["text"] for data in data_by_decile],
+        "backgroundColor": "#6a6af4",
+    }
+
+    return (datasets_histogram_bar_chart, deciles)
+
+
+def get_indicator_histogram_data(indicator, territory, submesh, filters):
+    indicator_details = {}
+    territory_values = get_values_for_submesh_territories(
+        indicator, submesh, territory, filters
+    )
+    datasets_histogram_bar_chart, deciles = get_territories_histogram_data(
+        territory_values, indicator.unite
+    )
+
+    indicator_details["datasetsHistogramBarChart"] = datasets_histogram_bar_chart
+    indicator_details["deciles"] = deciles
+
+    return indicator_details

territories_dashboard_lib/indicators_lib/query/indicator_card.py

@@ -0,0 +1,102 @@
+from .commons import generate_aggregate_query_for_location
+from .utils import run_custom_query
+
+
+def generate_min_max_queries(indicator):
+    result = """
+    , min_value AS (SELECT MIN(valeur) AS min FROM aggregat),
+    max_value AS (SELECT MAX(valeur) AS max FROM aggregat)
+    """
+    if indicator.is_composite:
+        result += """
+        , min_alternative_value AS (SELECT MIN(valeur_alternative) AS min_alternative FROM aggregat),
+        max_alternative_value AS (SELECT MAX(valeur_alternative) AS max_alternative FROM aggregat)
+        """
+    return result
+
+
+def get_min_max_statistics(indicator, submesh):
+    result = f"""
+    {get_values_for("min", submesh)}
+    {get_values_for("max", submesh)}
+    """
+    if indicator.is_composite:
+        result += f"""
+        {get_values_for("min_alternative", submesh, True)}
+        {get_values_for("max_alternative", submesh, True)}
+        """
+    return result
+
+
+def get_values_for(extremum, submesh, is_alternative=False):
+    return f"""
+    {extremum}_value,
+    (
+        SELECT code_{submesh} AS code_{extremum}
+        FROM aggregat
+        WHERE valeur{"_alternative" if is_alternative else ""} = (SELECT * FROM {extremum}_value) LIMIT 1
+    ) AS code_{extremum},
+    (
+        SELECT count(code_{submesh}) AS count_{extremum}
+        FROM aggregat
+        WHERE valeur{"_alternative" if is_alternative else ""} = (SELECT * FROM {extremum}_value)
+    ) AS count_{extremum},
+    """
+
+
+def get_med_values(indicator):
+    return f"""
+    (SELECT
+    PERCENTILE_DISC(0.5) WITHIN GROUP (order by valeur) AS med
+    {", PERCENTILE_DISC(0.5) WITHIN GROUP (order by valeur_alternative) AS med_alternative" if indicator.is_composite else ""}
+    FROM aggregat) AS meds
+    """
+
+
+def get_geography_statistics_values_for_indicator(
+    indicator, territory, submesh, filters
+):
+    query = f"""
+    {generate_aggregate_query_for_location(indicator, territory, submesh, filters)}
+    {generate_min_max_queries(indicator)}
+
+    SELECT * FROM
+    {get_min_max_statistics(indicator, submesh)}
+    {get_med_values(indicator)}
+    """
+
+    return query
+
+
+def get_indicator_filters(indicator):
+    if not indicator.db_table_prefix or not indicator.dimension:
+        return None
+
+    # Get the possible indicator's dimension's values
+    query = f"""
+SELECT DISTINCT({indicator.dimension}) as filter FROM "{indicator.db_table_prefix}_reg"
+"""
+    return query
+
+
+def get_names_from_codes(dict_result, submesh):
+    codes_to_fetch = []
+    for key, value in dict_result.items():
+        if key.startswith("code_"):
+            codes_to_fetch.append(value)
+    mapped_submesh = "DEPCOM" if submesh == "com" else submesh.upper()
+    query = f"""
+    SELECT DISTINCT "{mapped_submesh}" as code, "NOM_{mapped_submesh}" as name
+    FROM arborescence_geo
+    WHERE "{mapped_submesh}" IN ({", ".join(["'" + c + "'" for c in codes_to_fetch])});
+    """
+    rows = run_custom_query(query)
+    names_dict = {}
+    for row in rows:
+        names_dict[row["code"]] = row["name"]
+    updated_dict = {}
+    for key, value in dict_result.items():
+        updated_dict[key] = value
+        if key.startswith("code_"):
+            updated_dict[key + "_name"] = names_dict[value]
+    return updated_dict

territories_dashboard_lib/indicators_lib/query/top_10.py

@@ -0,0 +1,100 @@
+from collections import defaultdict
+
+from .commons import (
+    add_optional_filters,
+    calculate_aggregate_values,
+    get_last_year,
+    get_table_data_for_geography,
+)
+from .utils import get_breakdown_dimension, run_custom_query
+
+
+def breakdown_territories(indicator, submesh, year, filters, top_10_territories):
+    territories_code = ", ".join(
+        [f"'{territory['code_geo']}'" for territory in top_10_territories]
+    )
+    breakdown_dimension = get_breakdown_dimension(indicator).db_name
+
+    query = f"""
+        SELECT {calculate_aggregate_values(indicator, with_alternative=False)},
+            "{breakdown_dimension}" as dimension,
+            "code_{submesh}" as code_geo
+        FROM "{indicator.db_table_prefix}_{submesh}" as indic
+        WHERE code_{submesh} in ({territories_code}) AND annee = {year}
+        {add_optional_filters(indicator, filters)}
+        GROUP BY "code_{submesh}", "{breakdown_dimension}"
+    """
+    results = run_custom_query(query)
+    return results
+
+
+def get_top_10_territories(indicator, territory, submesh, year, filters):
+    query = f"""
+    SELECT {calculate_aggregate_values(indicator, with_alternative=False)},
+    indic.code_{submesh} as code_geo, arbo.lieu as lieu
+    FROM {get_table_data_for_geography(indicator, territory, submesh, include_place_names=True)}
+    {add_optional_filters(indicator, filters)}
+    AND annee = {year}
+    GROUP BY code_{submesh}, arbo.lieu
+    ORDER BY valeur DESC
+    LIMIT 10
+    """
+    results = run_custom_query(query)
+    return results
+
+
+def get_indicator_top_10_data(indicator, territory, submesh, filters):
+    indicator_details = {}
+
+    breakdown_dimension = get_breakdown_dimension(indicator)
+    breakdown_dimension = breakdown_dimension.db_name if breakdown_dimension else None
+    breakdown_filters = filters.get(breakdown_dimension, [])
+
+    last_year = get_last_year(indicator, submesh)
+
+    territories = get_top_10_territories(
+        indicator, territory, submesh, last_year, filters
+    )
+
+    if breakdown_dimension:
+        breakdown = breakdown_territories(
+            indicator, submesh, last_year, filters, territories
+        )
+        breakdown_by_geocode = defaultdict(dict)
+        for row in breakdown:
+            breakdown_by_geocode[row["code_geo"]][row["dimension"]] = row["valeur"]
+        datasets_top_bar_chart = [
+            {
+                "label": f,
+                "data": [
+                    breakdown_by_geocode[territory["code_geo"]][f]
+                    for territory in territories
+                ],
+            }
+            for f in breakdown_filters
+        ]
+    else:
+        datasets_top_bar_chart = [
+            {
+                "label": indicator.unite,
+                "data": [territory["valeur"] for territory in territories],
+            }
+        ]
+
+    labels_top_bar_chart = [territory["lieu"] for territory in territories]
+
+    csv_data = []
+    for territory in territories:
+        csv_row = {}
+        csv_row["Territoire"] = territory["lieu"]
+        csv_row["Code Géographique"] = territory["code_geo"]
+        csv_row[f"Valeur {indicator.unite}"] = territory["valeur"]
+        if breakdown_dimension:
+            for filter in breakdown_filters:
+                csv_row[filter] = breakdown_by_geocode[territory["code_geo"]][filter]
+        csv_data.append(csv_row)
+
+    indicator_details["labelsTopBarChart"] = labels_top_bar_chart
+    indicator_details["datasetsTopBarChart"] = datasets_top_bar_chart
+
+    return indicator_details, csv_data

territories_dashboard_lib/indicators_lib/query/utils.py

@@ -0,0 +1,20 @@
+from django.conf import settings
+from django.db import connections
+
+
+def get_breakdown_dimension(indicator):
+    breakdown_dimension = (
+        indicator.dimensions.filter(is_breakdown=True).first()
+        if indicator.dimensions.count() > 1
+        else indicator.dimensions.first()
+    )
+    return breakdown_dimension
+
+
+def run_custom_query(query, params=None):
+    with connections[settings.INDICATORS_DATABASE].cursor() as cursor:
+        cursor.execute(query, params)
+        columns = [col[0] for col in cursor.description]
+        rows = cursor.fetchall()
+        results = [dict(zip(columns, row)) for row in rows]
+        return results

territories_dashboard_lib/indicators_lib/refresh_filters.py

@@ -0,0 +1,17 @@
+from django.apps import apps
+
+from territories_dashboard_lib.indicators_lib.query.utils import run_custom_query
+
+
+def refresh_filters(dimension):
+    if dimension:
+        query = f'SELECT DISTINCT({dimension.db_name}) as filter FROM "{dimension.indicator.db_table_prefix}_reg"'
+        results = run_custom_query(query)
+        Filter = apps.get_model("tdbmd_indicators", "Filter")
+        Filter.objects.filter(dimension=dimension).delete()
+        Filter.objects.bulk_create(
+            [
+                Filter(dimension=dimension, db_name=value["filter"], order=index)
+                for index, value in enumerate(results)
+            ]
+        )