"""
Méthode permettant de manipuler les objets de la nomenclature
"""
from importlib import import_module
from flask import current_app
from .models import (
TNomenclatures,
BibNomenclaturesTypes,
TNomenclatureTaxonomy,
VNomenclatureTaxonomie,
BibNomenclaturesTypeTaxo,
)
from sqlalchemy import text, select
from .env import db
[docs]
def get_nomenclature_list(
id_type=None,
code_type=None,
regne=None,
group2_inpn=None,
group3_inpn=None,
hierarchy=None,
filter_params=None,
):
"""
Récupération de la liste des termes d'un type de nomenclature
"""
q = select(BibNomenclaturesTypes)
if filter_params is None:
filter_params = []
if code_type:
nomenclature = db.session.scalars(q.filter_by(mnemonique=code_type).limit(1)).first()
elif id_type:
nomenclature = db.session.scalars(q.filter_by(id_type=id_type).limit(1)).first()
else:
nomenclature = None
if not nomenclature:
return None
# Terme de nomenclatures
q = select(TNomenclatures).filter_by(id_type=nomenclature.id_type).filter_by(active=True)
# Filtrer sur la hiérarchie
if hierarchy:
q = q.where(TNomenclatures.hierarchy.like("{}%".format(hierarchy)))
if current_app.config["ENABLE_NOMENCLATURE_TAXONOMIC_FILTERS"]:
# Filtrer en fonction du groupe taxonomie
if regne:
q = q.join(
VNomenclatureTaxonomie,
VNomenclatureTaxonomie.id_nomenclature == TNomenclatures.id_nomenclature,
).where(VNomenclatureTaxonomie.regne.in_(("all", regne)))
if group2_inpn:
q = q.filter(VNomenclatureTaxonomie.group2_inpn.in_(("all", group2_inpn)))
if group3_inpn:
q = q.where(VNomenclatureTaxonomie.group3_inpn.in_(("all", group3_inpn)))
if "cd_nomenclature" in filter_params:
q = q.where(TNomenclatures.cd_nomenclature.in_(filter_params.getlist("cd_nomenclature")))
# Ordonnancement
if "orderby" in filter_params:
order_col = getattr(TNomenclatures, filter_params["orderby"])
if "order" in filter_params:
if filter_params["order"] == "desc":
order_col = order_col.desc()
q = q.order_by(order_col)
# @TODO Autres filtres
data = db.session.scalars(q).all()
response = nomenclature.as_dict()
if data:
response["values"] = [n.as_dict() for n in data]
return response
[docs]
def get_nomenclature_with_taxonomy_list():
"""
Fetch nomenclature definition list with taxonomy
"""
q = select(BibNomenclaturesTypeTaxo).order_by("mnemonique")
nomenclature_types = db.session.scalars(q).unique().all()
data = list()
for t in nomenclature_types:
nomenclature_type_dict = t.as_dict(
fields=[
"id_type",
"mnemonique",
"label_default",
"label_de",
"label_en",
"label_es",
"label_fr",
"label_it",
]
)
nomenclatures = list()
for n in t.taxonomic_nomenclatures:
nomenclature_dict = n.as_dict(
fields=[
"id_nomenclature",
"cd_nomenclature",
"mnemonique",
"hierarchy",
"label_default",
"label_de",
"label_en",
"label_es",
"label_fr",
"label_it",
]
)
nomenclature_dict["taxref"] = [
tr.as_dict(fields=["regne", "group2_inpn", "group3_inpn"]) for tr in n.taxref
]
nomenclatures.append(nomenclature_dict)
nomenclature_type_dict["nomenclatures"] = nomenclatures
data.append(nomenclature_type_dict)
return data
[docs]
def get_nomenclature_id_term(cd_type, cd_term, raise_exp=True):
"""
Fonction retournant l'identifiant d'un term
à partir de ses codes mnemoniques
paramètres:
----------
cd_type : code mnemonique du type de vocabulaire
cd_term : code du terme recherché
raise_exp : spécifie le comportement de la
fonction en cas d'exeception
"""
t = text("SELECT ref_nomenclatures.get_id_nomenclature(:cd_type, :cd_term) as id")
try:
value = db.session.scalars(
select("id").from_statement(t.params(cd_type=cd_type, cd_term=cd_term).limit(1))
).first()
return value
except Exception as e:
if raise_exp:
raise e
return None