Feat/declaratif model

app/modules/oeasc/chasse/api.py

@@ -119,7 +119,7 @@ def api_result_custom():
     out = {}
 
     for bracelet in ["CEM", "CEFF", "CEFFD"]:
-        params["bracelet"] = bracelet
+        params["code_type_bracelet"] = bracelet
         data = get_attribution_result(params)
         out[bracelet] = data
     return out

app/modules/oeasc/chasse/models.py

@@ -428,6 +428,39 @@ class VChasseBilan(DB.Model):
     nb_realise_avant_11 = DB.Column(DB.Integer())
 
 
+@serializable
+class VCustomResults(DB.Model):
+    """
+    Realisations
+    """
+
+    __tablename__ = "v_custom_results"
+    __table_args__ = {
+        "schema": "oeasc_chasse",
+        "extend_existing": True,
+    }
+
+    id_nomenclature_mode_chasse = DB.Column(DB.Integer())
+    label_mode_chasse = DB.Column(DB.Unicode())
+    label_sexe = DB.Column(DB.Unicode())
+    label_classe_age = DB.Column(DB.Unicode())
+    nom_espece = DB.Column(DB.Unicode())
+    id_espece = DB.Column(DB.Integer(), primary_key=True)
+    id_zone_cynegetique = DB.Column(DB.Integer(), primary_key=True)
+    nom_zone_indicative = DB.Column(DB.Unicode())
+    id_zone_indicative = DB.Column(DB.Integer(), primary_key=True)
+    nom_zone_indicative = DB.Column(DB.Unicode())
+    id_saison = DB.Column(DB.Integer(), primary_key=True)
+    nom_saison = DB.Column(DB.Unicode())
+    nom_saison = DB.Column(DB.Unicode())
+    id_saison = DB.Column(DB.Integer(), primary_key=True)
+    id_secteur = DB.Column(DB.Integer())
+    nom_secteur = DB.Column(DB.Unicode())
+    bracelet = DB.Column(DB.Unicode())
+    mois_txt = DB.Column(DB.Unicode())
+    mois_txt_sort = DB.Column(DB.Integer())
+
+
 # @serializable
 # class VChassePreBilan(DB.Model):
 #     '''

app/modules/oeasc/chasse/repositories.py

@@ -9,11 +9,15 @@
 from sqlalchemy import column, select, func, table, distinct, over, cast
 from ..commons.models import TEspeces, TSecteurs
 from .models import (
+    TRealisationsChasse,
     TSaisons,
     TZoneCynegetiques,
     TZoneIndicatives,
     TAttributionMassifs,
     VPlanChasseRealisationBilan,
+    TAttributions,
+    TRealisationsChasse,
+    TTypeBracelets,
 )
 
 config = current_app.config
@@ -56,23 +60,48 @@ def chasse_process_args():
 
 
 def get_attribution_result(params):
+    # mapping beetween params (filter) and db columns
+    filter_mapping = {
+        "id_saison": TAttributions.id_saison,
+        "id_espece": TTypeBracelets.id_espece,
+        "id_secteur": TZoneCynegetiques.id_secteur,
+        "id_zone_cynegetique": TAttributions.id_zone_cynegetique_affectee,
+        "id_zone_indicative": TAttributions.id_zone_indicative_affectee,
+        "code_type_bracelet": TTypeBracelets.code_type_bracelet,
+    }
 
-    columns = GenericTable(
-        "v_custom_result_attribution", "oeasc_chasse", DB.engine
-    ).tableDef.columns
-
-    query = DB.session.query(
-        func.count(columns.id_attribution),
-        func.count(columns.id_attribution).filter(columns.id_realisation != None),
+    query = (
+        DB.session.query(
+            func.count(TAttributions.id_attribution),
+            func.count(TAttributions.id_attribution).filter(
+                TRealisationsChasse.id_realisation != None
+            ),
+        )
+        .join(
+            TTypeBracelets,
+            TAttributions.id_type_bracelet == TTypeBracelets.id_type_bracelet,
+        )
+        .join(
+            TZoneCynegetiques,
+            TAttributions.id_zone_cynegetique_affectee
+            == TZoneCynegetiques.id_zone_cynegetique,
+        )
+        .outerjoin(
+            TRealisationsChasse,
+            TAttributions.id_attribution == TRealisationsChasse.id_attribution,
+        )
     )
 
     for filter_key, filter_value in params.items():
-        if not hasattr(columns, filter_key) or filter_value in [None, []]:
+        column_to_filter = filter_mapping.get(filter_key, None)
+
+        if not column_to_filter or filter_value in [None, []]:
             continue
+
         if isinstance(filter_value, list):
-            query = query.filter(getattr(columns, filter_key).in_(filter_value))
+            query = query.filter(column_to_filter.in_(filter_value))
         else:
-            query = query.filter(getattr(columns, filter_key) == (filter_value))
+            query = query.filter(column_to_filter == (filter_value))
 
     res = query.one()
 

app/modules/oeasc/resultat/api.py

@@ -10,19 +10,21 @@
 from utils_flask_sqla.generic import GenericQuery
 from ..user.utils import check_auth_redirect_login
 
-from .repository import result_custom, cache_generic_table
+from .repository import result_custom
 from ..generic.repository import getlist
 
+from ..chasse.models import VCustomResults
+
 config = current_app.config
 DB = config["DB"]
 bp = Blueprint("resultat_api", __name__)
 
 # pour les rendus customisés (route 'custom/')
 # dictionaire de relation entre
 #  - datatype : le type de données
-#  - view : la vue utilisée pour ce type de données
+#  - model : Model utilisé pour ce type de données
 data_type_view_dict = {
-    "chasse": "oeasc_chasse.v_custom_results",
+    "chasse": VCustomResults,
 }
 
 
@@ -78,8 +80,6 @@ def api_result_custom():
     - field_name : champs de la vue servant pour l'analyse
     - filters : quels filtres appliqués
     """
-
-    cache_generic_table = {}
     # gestion paramètres pour créer args
     args = {}
 
@@ -104,8 +104,6 @@ def api_result_custom():
     # récupération de la vue associée à data_type
     args["view"] = data_type_view_dict[args["data_type"]]
 
-    # print(json.dumps(args, indent=4))
-
     # exectution de la function oeasc_chasse.fct_custom_results_j
     # qui renvoie un objet de type dictionnaire
 
@@ -129,7 +127,6 @@ def api_result_custom():
 
     # pour garder en mémoire args['field_name']
     field_name_save = args["field_name"]
-
     # desormais on groupe par <field_name_2>
     args["field_name"] = args["field_name_2"]
 

app/modules/oeasc/resultat/repository.py

@@ -174,23 +174,16 @@ def req_timeline():
 
 def result_custom(params):
 
-    schema_name = params["view"].split(".")[0]
-    table_name = params["view"].split(".")[1]
-    if not cache_generic_table.get(params["view"]):
-        cache_generic_table[params["view"]] = GenericTable(
-            table_name, schema_name, DB.engine
-        )
-
-    view = cache_generic_table.get(params["view"])
+    view = params["view"]
 
     query = DB.session.query(
-        getattr(view.tableDef.columns, params["field_name"]), func.count("*")
+        getattr(view.__table__.columns, params["field_name"]), func.count("*")
     )
 
     # filter
     for filter_key, filter_value in params.get("filters", {}).items():
         query = query.filter(
-            getattr(view.tableDef.columns, filter_key).in_(filter_value)
+            getattr(view.__table__.columns, filter_key).in_(filter_value)
         )
 
     group_bys = [params["field_name"]]

data/chasse/result_custom.sql

@@ -64,7 +64,7 @@
 	;
 
 
-
+-- TO DELETE UNUSED
 	DROP VIEW IF EXISTS oeasc_chasse.v_custom_result_attribution;
 	CREATE OR REPLACE VIEW oeasc_chasse.v_custom_result_attribution AS
 	SELECT