class TBaseSites(DB.Model):
"""
Table centralisant les données élémentaire des sites
"""
__tablename__ = "t_base_sites"
__table_args__ = {"schema": "gn_monitoring"}
id_base_site = DB.Column(DB.Integer, primary_key=True)
id_inventor = DB.Column(DB.Integer,
ForeignKey("utilisateurs.t_roles.id_role"))
id_digitiser = DB.Column(DB.Integer,
ForeignKey("utilisateurs.t_roles.id_role"))
id_nomenclature_type_site = DB.Column(DB.Integer)
base_site_name = DB.Column(DB.Unicode)
base_site_description = DB.Column(DB.Unicode)
base_site_code = DB.Column(DB.Unicode)
first_use_date = DB.Column(DB.DateTime)
geom = DB.Column(Geometry("GEOMETRY", 4326))
uuid_base_site = DB.Column(UUID(as_uuid=True),
default=select([func.uuid_generate_v4()]))
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
digitiser = relationship(User,
primaryjoin=(User.id_role == id_digitiser),
foreign_keys=[id_digitiser])
inventor = relationship(User,
primaryjoin=(User.id_role == id_inventor),
foreign_keys=[id_inventor])
t_base_visits = relationship("TBaseVisits",
lazy="select",
cascade="all,delete-orphan")
modules = DB.relationship(
"TModules",
lazy="select",
secondary=corSiteModule,
primaryjoin=(corSiteModule.c.id_base_site == id_base_site),
secondaryjoin=(corSiteModule.c.id_module == TModules.id_module),
foreign_keys=[corSiteModule.c.id_base_site, corSiteModule.c.id_module],
)
def get_geofeature(self, recursif=True):
return self.as_geofeature("geom", "id_base_site", recursif)
class BibFields(DB.Model):
__tablename__ = "dict_fields"
__table_args__ = {"schema": "gn_imports", "extend_existing": True}
id_field = DB.Column(DB.Integer, primary_key=True)
name_field = DB.Column(DB.Unicode, nullable=False)
fr_label = DB.Column(DB.Unicode, nullable=False)
eng_label = DB.Column(DB.Unicode, nullable=True)
desc_field = DB.Column(DB.Unicode, nullable=True)
type_field = DB.Column(DB.Unicode, nullable=True)
synthese_field = DB.Column(DB.Boolean, nullable=False)
mandatory = DB.Column(DB.Boolean, nullable=False)
autogenerate = DB.Column(DB.Boolean, nullable=False)
nomenclature = DB.Column(DB.Boolean, nullable=False)
id_theme = DB.Column(DB.Integer, nullable=False)
order_field = DB.Column(DB.Integer, nullable=False)
comment = DB.Column(DB.Unicode)
class CorRoleImport(DB.Model):
__tablename__ = "cor_role_import"
__table_args__ = {"schema": "gn_imports", "extend_existing": True}
id_role = DB.Column(DB.Integer, primary_key=True)
id_import = DB.Column(DB.Integer, primary_key=True)
class SyntheseOneRecord(VSyntheseDecodeNomenclatures):
"""
Model for display details information about one synthese observation
Herited from VSyntheseDecodeNomenclatures model for all decoded nomenclatures
"""
__tablename__ = "synthese"
__table_args__ = {"schema": "gn_synthese", "extend_existing": True}
id_synthese = DB.Column(
DB.Integer,
ForeignKey("gn_synthese.v_synthese_decode_nomenclatures.id_synthese"),
primary_key=True,
)
unique_id_sinp = DB.Column(UUID(as_uuid=True))
id_source = DB.Column(DB.Integer)
id_dataset = DB.Column(DB.Integer)
cd_hab = DB.Column(DB.Integer, ForeignKey(Habref.cd_hab))
habitat = DB.relationship(Habref, lazy="joined")
source = DB.relationship(
"TSources",
primaryjoin=(TSources.id_source == id_source),
foreign_keys=[id_source],
)
areas = DB.relationship(
"LAreas",
secondary=corAreaSynthese,
primaryjoin=(corAreaSynthese.c.id_synthese == id_synthese),
secondaryjoin=(corAreaSynthese.c.id_area == LAreas.id_area),
foreign_keys=[
corAreaSynthese.c.id_synthese, corAreaSynthese.c.id_area
],
)
datasets = DB.relationship(
"TDatasets",
primaryjoin=(TDatasets.id_dataset == id_dataset),
foreign_keys=[id_dataset],
)
acquisition_framework = DB.relationship(
"TAcquisitionFramework",
uselist=False,
secondary=TDatasets.__table__,
primaryjoin=(TDatasets.id_dataset == id_dataset),
secondaryjoin=(TDatasets.id_acquisition_framework ==
TAcquisitionFramework.id_acquisition_framework),
)
cor_observers = DB.relationship(
"User",
uselist=True,
secondary=CorObserverSynthese.__table__,
primaryjoin=(CorObserverSynthese.id_synthese == id_synthese),
secondaryjoin=(User.id_role == CorObserverSynthese.id_role),
)
validations = DB.relationship(
"TValidations",
primaryjoin=(TValidations.uuid_attached_row == unique_id_sinp),
foreign_keys=[unique_id_sinp],
uselist=True,
)
medias = DB.relationship(
TMedias,
primaryjoin=(unique_id_sinp == TMedias.uuid_attached_row),
foreign_keys=[TMedias.uuid_attached_row],
)
class THabitatsOcchab(DB.Model):
__tablename__ = "t_habitats"
__table_args__ = {"schema": "pr_occhab"}
id_habitat = DB.Column(DB.Integer, primary_key=True)
id_station = DB.Column(DB.Integer,
ForeignKey("pr_occhab.t_stations.id_station"))
unique_id_sinp_hab = DB.Column(UUID(as_uuid=True),
default=select([func.uuid_generate_v4()]))
cd_hab = DB.Column(DB.Integer, ForeignKey('ref_habitats.habref.cd_hab'))
nom_cite = DB.Column(DB.Unicode)
id_nomenclature_determination_type = DB.Column(
DB.Integer, ForeignKey(TNomenclatures.id_nomenclature))
determiner = DB.Column(DB.Unicode)
id_nomenclature_collection_technique = DB.Column(
DB.Integer, ForeignKey(TNomenclatures.id_nomenclature))
recovery_percentage = DB.Column(DB.Float)
id_nomenclature_abundance = DB.Column(
DB.Integer, ForeignKey(TNomenclatures.id_nomenclature))
technical_precision = DB.Column(DB.Unicode)
id_nomenclature_sensitvity = DB.Column(DB.Integer)
habref = DB.relationship("Habref", lazy="joined")
class VSyntheseDecodeNomenclatures(DB.Model):
__tablename__ = "v_synthese_decode_nomenclatures"
__table_args__ = {"schema": "gn_synthese"}
id_synthese = DB.Column(DB.Integer, primary_key=True)
nat_obj_geo = DB.Column(DB.Unicode)
grp_typ = DB.Column(DB.Unicode)
obs_technique = DB.Column(DB.Unicode)
bio_status = DB.Column(DB.Unicode)
bio_condition = DB.Column(DB.Unicode)
naturalness = DB.Column(DB.Unicode)
exist_proof = DB.Column(DB.Unicode)
valid_status = DB.Column(DB.Unicode)
diffusion_level = DB.Column(DB.Unicode)
life_stage = DB.Column(DB.Unicode)
sex = DB.Column(DB.Unicode)
obj_count = DB.Column(DB.Unicode)
type_count = DB.Column(DB.Unicode)
sensitivity = DB.Column(DB.Unicode)
observation_status = DB.Column(DB.Unicode)
blurring = DB.Column(DB.Unicode)
source_status = DB.Column(DB.Unicode)
occ_behaviour = DB.Column(DB.Unicode)
class CorAreaSynthese(DB.Model):
__tablename__ = "cor_area_synthese"
__table_args__ = {"schema": "gn_synthese"}
id_synthese = DB.Column(DB.Integer, primary_key=True)
id_area = DB.Column(DB.Integer)
class TAcquisitionFramework(CruvedMixin, FilterMixin, db.Model):
__tablename__ = "t_acquisition_frameworks"
__table_args__ = {"schema": "gn_meta"}
query_class = TAcquisitionFrameworkQuery
id_acquisition_framework = DB.Column(DB.Integer, primary_key=True)
unique_acquisition_framework_id = DB.Column(
UUIDType(as_uuid=True), default=select([func.uuid_generate_v4()])
)
acquisition_framework_name = DB.Column(DB.Unicode(255))
acquisition_framework_desc = DB.Column(DB.Unicode)
id_nomenclature_territorial_level = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("NIVEAU_TERRITORIAL"),
)
territory_desc = DB.Column(DB.Unicode)
keywords = DB.Column(DB.Unicode)
id_nomenclature_financing_type = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("TYPE_FINANCEMENT"),
)
target_description = DB.Column(DB.Unicode)
ecologic_or_geologic_target = DB.Column(DB.Unicode)
acquisition_framework_parent_id = DB.Column(DB.Integer)
is_parent = DB.Column(DB.Boolean)
opened = DB.Column(DB.Boolean, default=True)
id_digitizer = DB.Column(DB.Integer, ForeignKey(User.id_role))
acquisition_framework_start_date = DB.Column(DB.Date, default=datetime.datetime.utcnow)
acquisition_framework_end_date = DB.Column(DB.Date)
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
initial_closing_date = DB.Column(DB.DateTime)
creator = DB.relationship(User, lazy="joined") # = digitizer
nomenclature_territorial_level = DB.relationship(
TNomenclatures,
lazy="select",
primaryjoin=(TNomenclatures.id_nomenclature == id_nomenclature_territorial_level),
)
nomenclature_financing_type = DB.relationship(
TNomenclatures,
lazy="select",
primaryjoin=(TNomenclatures.id_nomenclature == id_nomenclature_financing_type),
)
cor_af_actor = relationship(
CorAcquisitionFrameworkActor,
lazy="joined",
#cascade="save-update, merge, delete, delete-orphan",
cascade="all,delete-orphan",
uselist=True,
backref=DB.backref("actor_af", lazy="select")
)
cor_objectifs = DB.relationship(
TNomenclatures,
lazy="select",
secondary=CorAcquisitionFrameworkObjectif.__table__,
primaryjoin=(
CorAcquisitionFrameworkObjectif.id_acquisition_framework == id_acquisition_framework
),
secondaryjoin=(
CorAcquisitionFrameworkObjectif.id_nomenclature_objectif
== TNomenclatures.id_nomenclature
),
foreign_keys=[
CorAcquisitionFrameworkObjectif.id_acquisition_framework,
CorAcquisitionFrameworkObjectif.id_nomenclature_objectif,
],
backref=DB.backref("objectif_af", lazy="select")
)
cor_volets_sinp = DB.relationship(
TNomenclatures,
lazy="select",
secondary=CorAcquisitionFrameworkVoletSINP.__table__,
primaryjoin=(CorAcquisitionFrameworkVoletSINP.id_acquisition_framework == id_acquisition_framework),
secondaryjoin=(CorAcquisitionFrameworkVoletSINP.id_nomenclature_voletsinp == TNomenclatures.id_nomenclature),
foreign_keys=[
CorAcquisitionFrameworkVoletSINP.id_acquisition_framework,
CorAcquisitionFrameworkVoletSINP.id_nomenclature_voletsinp,
],
backref=DB.backref("volet_sinp_af", lazy="select")
)
cor_territories = DB.relationship(
TNomenclatures,
lazy="select",
secondary=CorAcquisitionFrameworkTerritory.__table__,
primaryjoin=(CorAcquisitionFrameworkTerritory.id_acquisition_framework == id_acquisition_framework),
secondaryjoin=(CorAcquisitionFrameworkTerritory.id_nomenclature_territory == TNomenclatures.id_nomenclature),
foreign_keys=[
CorAcquisitionFrameworkTerritory.id_acquisition_framework,
CorAcquisitionFrameworkTerritory.id_nomenclature_territory,
],
backref=DB.backref("territory_af", lazy="select")
)
bibliographical_references = DB.relationship(
"TBibliographicReference",
lazy="select",
cascade="all,delete-orphan",
uselist=True,
backref=DB.backref("acquisition_framework", lazy="select"),
)
t_datasets = DB.relationship(
"TDatasets",
lazy="joined", # DS required for permissions checks
cascade="all,delete-orphan",
uselist=True,
)
datasets = synonym("t_datasets")
@hybrid_property
def user_actors(self):
return [ actor.role for actor in self.cor_af_actor if actor.role is not None ]
@hybrid_property
def organism_actors(self):
return [ actor.organism for actor in self.cor_af_actor if actor.organism is not None ]
def is_deletable(self):
return not db.session.query(
TDatasets.query
.filter_by(id_acquisition_framework=self.id_acquisition_framework)
.exists()
).scalar()
def has_instance_permission(self, scope, _through_ds=True):
if scope == 0:
return False
elif scope in (1, 2):
if g.current_user == self.creator or g.current_user in self.user_actors:
return True
if scope == 2 and g.current_user.organisme in self.organism_actors:
return True
# rights on DS give rights on AF!
return _through_ds and any(map(lambda ds: ds.has_instance_permission(scope, _through_af=False), self.t_datasets))
elif scope == 3:
return True
@staticmethod
def get_id(uuid_af):
"""
return the acquisition framework's id
from its UUID if exist or None
"""
a_f = (
DB.session.query(TAcquisitionFramework.id_acquisition_framework)
.filter(TAcquisitionFramework.unique_acquisition_framework_id == uuid_af)
.first()
)
if a_f:
return a_f[0]
return a_f
@staticmethod
def get_user_af(user, only_query=False, only_user=False):
"""get the af(s) where the user is actor (himself or with its organism - only himelsemf id only_use=True) or digitizer
param:
- user from TRole model
- only_query: boolean (return the query not the id_datasets allowed if true)
- only_user: boolean: return only the dataset where user himself is actor (not with its organoism)
return: a list of id_dataset or a query"""
q = DB.session.query(TAcquisitionFramework.id_acquisition_framework).outerjoin(
CorAcquisitionFrameworkActor,
CorAcquisitionFrameworkActor.id_acquisition_framework
== TAcquisitionFramework.id_acquisition_framework,
)
if user.id_organisme is None or only_user:
q = q.filter(
or_(
CorAcquisitionFrameworkActor.id_role == user.id_role,
TAcquisitionFramework.id_digitizer == user.id_role,
)
)
else:
q = q.filter(
or_(
CorAcquisitionFrameworkActor.id_organism == user.id_organisme,
CorAcquisitionFrameworkActor.id_role == user.id_role,
TAcquisitionFramework.id_digitizer == user.id_role,
)
)
if only_query:
return q
data = q.all()
return list(set([d.id_acquisition_framework for d in data]))
@classmethod
def compute_filter(cls, **kwargs):
f = super().compute_filter(**kwargs)
uuid = kwargs.get('uuid')
if uuid is not None:
try:
uuid = UUID(uuid.strip())
except TypeError:
pass
else:
f &= TAcquisitionFramework.unique_acquisition_framework_id == uuid
name = kwargs.get('name')
if name is not None:
f &= TAcquisitionFramework.acquisition_framework_name.ilike(f'%{name}%')
return f
class CorCountingOccurrence(DB.Model):
__tablename__ = "cor_counting_occtax"
__table_args__ = {"schema": "pr_occtax"}
id_counting_occtax = DB.Column(DB.Integer, primary_key=True)
unique_id_sinp_occtax = DB.Column(
UUID(as_uuid=True), default=select([func.uuid_generate_v4()]), nullable=False
)
id_occurrence_occtax = DB.Column(
DB.Integer,
ForeignKey("pr_occtax.t_occurrences_occtax.id_occurrence_occtax"),
nullable=False,
)
id_nomenclature_life_stage = DB.Column(DB.Integer, nullable=False)
id_nomenclature_sex = DB.Column(DB.Integer, nullable=False)
id_nomenclature_obj_count = DB.Column(DB.Integer, nullable=False)
id_nomenclature_type_count = DB.Column(DB.Integer)
count_min = DB.Column(DB.Integer)
count_max = DB.Column(DB.Integer)
#additionnal fields dans occtax MET 14/10/2020
additional_fields = DB.Column(JSONB)
readonly_fields = [
"id_counting_occtax",
"unique_id_sinp_occtax",
"id_occurrence_occtax",
]
medias = DB.relationship(
TMedias,
primaryjoin=('TMedias.uuid_attached_row == CorCountingOccurrence.unique_id_sinp_occtax'),
foreign_keys=[TMedias.uuid_attached_row],
cascade="all",
lazy="select",
)
class CorDatasetProtocol(DB.Model):
__tablename__ = "cor_dataset_protocol"
__table_args__ = {"schema": "gn_meta"}
id_cdp = DB.Column(DB.Integer, primary_key=True)
id_dataset = DB.Column(DB.Integer, ForeignKey("gn_meta.t_datasets.id_dataset"))
id_protocol = DB.Column(DB.Integer, ForeignKey("gn_meta.sinp_datatype_protocols.id_protocol"))
class TDatasets(CruvedMixin, FilterMixin, db.Model):
__tablename__ = "t_datasets"
__table_args__ = {"schema": "gn_meta"}
query_class = TDatasetsQuery
id_dataset = DB.Column(DB.Integer, primary_key=True)
unique_dataset_id = DB.Column(UUIDType(as_uuid=True), default=select([func.uuid_generate_v4()]))
id_acquisition_framework = DB.Column(
DB.Integer, ForeignKey("gn_meta.t_acquisition_frameworks.id_acquisition_framework"),
)
acquisition_framework = DB.relationship("TAcquisitionFramework", lazy="joined") # join AF as required for permissions checks
dataset_name = DB.Column(DB.Unicode)
dataset_shortname = DB.Column(DB.Unicode)
dataset_desc = DB.Column(DB.Unicode)
id_nomenclature_data_type = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("DATA_TYP"),
)
keywords = DB.Column(DB.Unicode)
marine_domain = DB.Column(DB.Boolean)
terrestrial_domain = DB.Column(DB.Boolean)
id_nomenclature_dataset_objectif = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("JDD_OBJECTIFS"),
)
bbox_west = DB.Column(DB.Float)
bbox_east = DB.Column(DB.Float)
bbox_south = DB.Column(DB.Float)
bbox_north = DB.Column(DB.Float)
id_nomenclature_collecting_method = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("METHO_RECUEIL"),
)
id_nomenclature_data_origin = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("DS_PUBLIQUE"),
)
id_nomenclature_source_status = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("STATUT_SOURCE"),
)
id_nomenclature_resource_type = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("RESOURCE_TYP"),
)
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
active = DB.Column(DB.Boolean, default=True)
validable = DB.Column(DB.Boolean, server_default=FetchedValue())
id_digitizer = DB.Column(DB.Integer, ForeignKey(User.id_role))
digitizer = DB.relationship(User, lazy="joined") # joined for permission check
id_taxa_list = DB.Column(DB.Integer)
modules = DB.relationship("TModules", secondary=cor_module_dataset, lazy="select")
creator = DB.relationship(User, lazy="joined") # = digitizer
nomenclature_data_type = DB.relationship(
TNomenclatures,
lazy="select",
foreign_keys=[id_nomenclature_data_type],
)
nomenclature_dataset_objectif = DB.relationship(
TNomenclatures,
lazy="select",
foreign_keys=[id_nomenclature_dataset_objectif],
)
nomenclature_collecting_method = DB.relationship(
TNomenclatures,
lazy="select",
foreign_keys=[id_nomenclature_collecting_method],
)
nomenclature_data_origin = DB.relationship(
TNomenclatures,
lazy="select",
foreign_keys=[id_nomenclature_data_origin],
)
nomenclature_source_status = DB.relationship(
TNomenclatures,
lazy="select",
foreign_keys=[id_nomenclature_source_status],
)
nomenclature_resource_type = DB.relationship(
TNomenclatures,
lazy="select",
foreign_keys=[id_nomenclature_resource_type],
)
cor_territories = DB.relationship(
TNomenclatures,
lazy="select",
secondary=CorDatasetTerritory.__table__,
primaryjoin=(CorDatasetTerritory.id_dataset == id_dataset),
secondaryjoin=(CorDatasetTerritory.id_nomenclature_territory == TNomenclatures.id_nomenclature),
foreign_keys=[
CorDatasetTerritory.id_dataset,
CorDatasetTerritory.id_nomenclature_territory,
],
backref=DB.backref("territory_dataset", lazy="select")
)
# because CorDatasetActor could be an User or an Organisme object...
cor_dataset_actor = relationship(
CorDatasetActor,
lazy="joined",
cascade="save-update, merge, delete, delete-orphan",
backref=DB.backref("actor_dataset", lazy="select")
)
@hybrid_property
def user_actors(self):
return [ actor.role for actor in self.cor_dataset_actor if actor.role is not None ]
@hybrid_property
def organism_actors(self):
return [ actor.organism for actor in self.cor_dataset_actor if actor.organism is not None ]
def is_deletable(self):
return not DB.session.query(self.synthese_records.exists()).scalar()
def has_instance_permission(self, scope, _through_af=True):
"""
_through_af prevent infinite recursion
"""
if scope == 0:
return False
elif scope in (1, 2):
if g.current_user == self.digitizer or g.current_user in self.user_actors:
return True
if scope == 2 and g.current_user.organisme in self.organism_actors:
return True
return _through_af and self.acquisition_framework.has_instance_permission(scope, _through_ds=False)
elif scope == 3:
return True
def __str__(self):
return self.dataset_name
@staticmethod
def get_id(uuid_dataset):
id_dataset = (
DB.session.query(TDatasets.id_dataset)
.filter(TDatasets.unique_dataset_id == uuid_dataset)
.first()
)
if id_dataset:
return id_dataset[0]
return id_dataset
@staticmethod
def get_uuid(id_dataset):
uuid_dataset = (
DB.session.query(TDatasets.unique_dataset_id)
.filter(TDatasets.id_dataset == id_dataset)
.first()
)
if uuid_dataset:
return uuid_dataset[0]
return uuid_dataset
@classmethod
def compute_filter(cls, **kwargs):
f = super().compute_filter(**kwargs)
uuid = kwargs.get('uuid')
if uuid is not None:
try:
uuid = UUID(uuid.strip())
except TypeError:
pass
else:
f &= TDatasets.unique_dataset_id == uuid
name = kwargs.get('name')
if name is not None:
f &= TDatasets.dataset_name.ilike(f'%{name}%')
return f
class CorDatasetActor(DB.Model):
__tablename__ = "cor_dataset_actor"
__table_args__ = {"schema": "gn_meta"}
id_cda = DB.Column(DB.Integer, primary_key=True)
id_dataset = DB.Column(DB.Integer, ForeignKey("gn_meta.t_datasets.id_dataset"))
id_role = DB.Column(DB.Integer, ForeignKey(User.id_role))
id_organism = DB.Column(DB.Integer, ForeignKey(Organisme.id_organisme))
id_nomenclature_actor_role = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("ROLE_ACTEUR"),
)
nomenclature_actor_role = DB.relationship(
TNomenclatures,
lazy="joined",
foreign_keys=[id_nomenclature_actor_role],
)
role = DB.relationship(User, lazy="joined")
organism = relationship(Organisme, lazy="joined")
@hybrid_property
def actor(self):
if self.role is not None:
return self.role
else:
return self.organism
@hybrid_property
def display(self):
if self.role:
actor = self.role.nom_complet
else:
actor = self.organism.nom_organisme
return '{} ({})'.format(actor, self.nomenclature_actor_role.label_default)
@staticmethod
def get_actor(id_dataset, id_nomenclature_actor_role, id_role=None, id_organism=None):
"""
Get CorDatasetActor from id_dataset, id_actor, and id_role or id_organism.
if no object return None
"""
try:
if id_role is None:
return (
DB.session.query(CorDatasetActor)
.filter_by(
id_dataset=id_dataset,
id_organism=id_organism,
id_nomenclature_actor_role=id_nomenclature_actor_role,
)
.one()
)
elif id_organism is None:
return (
DB.session.query(CorDatasetActor)
.filter_by(
id_dataset=id_dataset,
id_role=id_role,
id_nomenclature_actor_role=id_nomenclature_actor_role,
)
.one()
)
except exc.NoResultFound:
return None
class CorAcquisitionFrameworkActor(DB.Model):
__tablename__ = "cor_acquisition_framework_actor"
__table_args__ = {"schema": "gn_meta"}
id_cafa = DB.Column(DB.Integer, primary_key=True)
id_acquisition_framework = DB.Column(
DB.Integer, ForeignKey("gn_meta.t_acquisition_frameworks.id_acquisition_framework"),
)
id_role = DB.Column(DB.Integer, ForeignKey(User.id_role))
id_organism = DB.Column(DB.Integer, ForeignKey(Organisme.id_organisme))
id_nomenclature_actor_role = DB.Column(
DB.Integer,
ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"),
default=lambda: TNomenclatures.get_default_nomenclature("ROLE_ACTEUR"),
)
nomenclature_actor_role = DB.relationship(
TNomenclatures,
lazy="joined",
primaryjoin=(TNomenclatures.id_nomenclature == id_nomenclature_actor_role),
)
role = DB.relationship(
User,
lazy="joined",
)
organism = relationship(
Organisme,
lazy="joined",
)
@staticmethod
def get_actor(
id_acquisition_framework, id_nomenclature_actor_role, id_role=None, id_organism=None,
):
"""
Get CorAcquisitionFrameworkActor from id_dataset, id_actor, and id_role or id_organism.
if no object return None
"""
try:
if id_role is None:
return (
DB.session.query(CorAcquisitionFrameworkActor)
.filter_by(
id_acquisition_framework=id_acquisition_framework,
id_organism=id_organism,
id_nomenclature_actor_role=id_nomenclature_actor_role,
)
.one()
)
elif id_organism is None:
return (
DB.session.query(CorAcquisitionFrameworkActor)
.filter_by(
id_acquisition_framework=id_acquisition_framework,
id_role=id_role,
id_nomenclature_actor_role=id_nomenclature_actor_role,
)
.one()
)
except exc.NoResultFound:
return None
class TBaseVisits(DB.Model):
"""
Table de centralisation des visites liées à un site
"""
__tablename__ = "t_base_visits"
__table_args__ = {"schema": "gn_monitoring"}
id_base_visit = DB.Column(DB.Integer, primary_key=True)
id_base_site = DB.Column(
DB.Integer, ForeignKey("gn_monitoring.t_base_sites.id_base_site"))
id_digitiser = DB.Column(DB.Integer,
ForeignKey("utilisateurs.t_roles.id_role"))
id_dataset = DB.Column(DB.Integer,
ForeignKey("gn_meta.t_datasets.id_dataset"))
# Pour le moment non défini comme une clé étrangère
# pour les questions de perfs
# a voir en fonction des usage
id_module = DB.Column(DB.Integer)
visit_date_min = DB.Column(DB.DateTime)
visit_date_max = DB.Column(DB.DateTime)
id_nomenclature_obs_technique = DB.Column(DB.Integer)
id_nomenclature_grp_typ = DB.Column(DB.Integer)
comments = DB.Column(DB.DateTime)
uuid_base_visit = DB.Column(UUID(as_uuid=True),
default=select([func.uuid_generate_v4()]))
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
digitiser = relationship(User,
primaryjoin=(User.id_role == id_digitiser),
foreign_keys=[id_digitiser])
observers = DB.relationship(
User,
secondary=corVisitObserver,
primaryjoin=(corVisitObserver.c.id_base_visit == id_base_visit),
secondaryjoin=(corVisitObserver.c.id_role == User.id_role),
foreign_keys=[
corVisitObserver.c.id_base_visit, corVisitObserver.c.id_role
],
)
dataset = relationship(TDatasets,
lazy="joined",
primaryjoin=(TDatasets.id_dataset == id_dataset),
foreign_keys=[id_dataset])
class TMedias(DB.Model):
__tablename__ = "t_medias"
__table_args__ = {"schema": "gn_commons"}
id_media = DB.Column(DB.Integer, primary_key=True)
id_nomenclature_media_type = DB.Column(
DB.Integer
# ,
# ForeignKey('ref_nomenclatures.t_nomenclatures.id_nomenclature')
)
id_table_location = DB.Column(
DB.Integer,
ForeignKey("gn_commons.bib_tables_location.id_table_location"))
unique_id_media = DB.Column(UUID(as_uuid=True),
default=select([func.uuid_generate_v4()]))
uuid_attached_row = DB.Column(UUID(as_uuid=True))
title_fr = DB.Column(DB.Unicode)
title_en = DB.Column(DB.Unicode)
title_it = DB.Column(DB.Unicode)
title_es = DB.Column(DB.Unicode)
title_de = DB.Column(DB.Unicode)
media_url = DB.Column(DB.Unicode)
media_path = DB.Column(DB.Unicode)
author = DB.Column(DB.Unicode)
description_fr = DB.Column(DB.Unicode)
description_en = DB.Column(DB.Unicode)
description_it = DB.Column(DB.Unicode)
description_es = DB.Column(DB.Unicode)
description_de = DB.Column(DB.Unicode)
is_public = DB.Column(DB.Boolean, default=True)
class TOccurrencesOccurrence(DB.Model):
__tablename__ = "t_occurrences_occtax"
__table_args__ = {"schema": "pr_occtax"}
id_occurrence_occtax = DB.Column(DB.Integer, primary_key=True)
id_releve_occtax = DB.Column(
DB.Integer, ForeignKey("pr_occtax.t_releves_occtax.id_releve_occtax")
)
id_nomenclature_obs_technique = DB.Column(DB.Integer)
id_nomenclature_bio_condition = DB.Column(DB.Integer)
id_nomenclature_bio_status = DB.Column(DB.Integer)
id_nomenclature_naturalness = DB.Column(DB.Integer)
id_nomenclature_exist_proof = DB.Column(DB.Integer)
id_nomenclature_observation_status = DB.Column(DB.Integer)
id_nomenclature_blurring = DB.Column(DB.Integer)
id_nomenclature_source_status = DB.Column(DB.Integer)
determiner = DB.Column(DB.Unicode)
id_nomenclature_determination_method = DB.Column(DB.Integer)
id_nomenclature_behaviour = DB.Column(DB.Integer)
cd_nom = DB.Column(DB.Integer, ForeignKey(Taxref.cd_nom))
nom_cite = DB.Column(DB.Unicode)
meta_v_taxref = DB.Column(
DB.Unicode,
default=select([func.gn_commons.get_default_parameter("taxref_version")]),
)
sample_number_proof = DB.Column(DB.Unicode)
digital_proof = DB.Column(DB.Unicode)
non_digital_proof = DB.Column(DB.Unicode)
comment = DB.Column(DB.Unicode)
#additionnal fields dans occtax MET 28/09/2020
additional_fields = DB.Column(JSONB)
unique_id_occurence_occtax = DB.Column(
UUID(as_uuid=True),
default=select([func.uuid_generate_v4()]),
)
cor_counting_occtax = relationship(
"CorCountingOccurrence",
lazy="joined",
cascade="all,delete-orphan",
uselist=True,
backref=DB.backref("occurence", lazy="joined"),
)
taxref = relationship("Taxref", lazy="joined")
readonly_fields = ["id_occurrence_occtax", "id_releve_occtax", "taxref"]
__table_args__ = {"schema": "gn_synthese"}
id_synthese = DB.Column(DB.Integer,
ForeignKey("gn_synthese.synthese.id_synthese"),
primary_key=True)
id_role = DB.Column(DB.Integer,
ForeignKey("utilisateurs.t_roles.id_role"),
primary_key=True)
corAreaSynthese = DB.Table(
"cor_area_synthese",
DB.MetaData(schema="gn_synthese"),
DB.Column(
"id_synthese",
DB.Integer,
ForeignKey("gn_synthese.cor_area_synthese.id_synthese"),
primary_key=True,
),
DB.Column("id_area",
DB.Integer,
ForeignKey("ref_geo.t_areas.id_area"),
primary_key=True),
)
@serializable
class VSyntheseDecodeNomenclatures(DB.Model):
__tablename__ = "v_synthese_decode_nomenclatures"
__table_args__ = {"schema": "gn_synthese"}
id_synthese = DB.Column(DB.Integer, primary_key=True)
nat_obj_geo = DB.Column(DB.Unicode)
grp_typ = DB.Column(DB.Unicode)
class TRelevesOccurrence(ReleveModel):
__tablename__ = "t_releves_occtax"
__table_args__ = {"schema": "pr_occtax"}
id_releve_occtax = DB.Column(DB.Integer, primary_key=True)
unique_id_sinp_grp = DB.Column(
UUID(as_uuid=True), default=select([func.uuid_generate_v4()])
)
id_dataset = DB.Column(DB.Integer, ForeignKey("gn_meta.t_datasets.id_dataset"))
id_digitiser = DB.Column(DB.Integer, ForeignKey("utilisateurs.t_roles.id_role"))
id_nomenclature_grp_typ = DB.Column(DB.Integer)
grp_method = DB.Column(DB.Unicode)
observers_txt = DB.Column(DB.Unicode)
date_min = DB.Column(DB.DateTime)
date_max = DB.Column(DB.DateTime)
hour_min = DB.Column(DB.DateTime)
hour_max = DB.Column(DB.DateTime)
altitude_min = DB.Column(DB.Integer)
altitude_max = DB.Column(DB.Integer)
depth_min = DB.Column(DB.Integer)
depth_max = DB.Column(DB.Integer)
id_nomenclature_tech_collect_campanule = DB.Column(DB.Integer)
id_nomenclature_geo_object_nature = DB.Column(DB.Integer)
meta_device_entry = DB.Column(DB.Unicode)
comment = DB.Column(DB.Unicode)
place_name = DB.Column(DB.Unicode)
geom_4326 = DB.Column(Geometry("GEOMETRY", 4326))
geom_local = DB.Column(Geometry("GEOMETRY", current_app.config["LOCAL_SRID"]))
cd_hab = DB.Column(DB.Integer, ForeignKey(Habref.cd_hab))
precision = DB.Column(DB.Integer)
habitat = relationship(Habref, lazy="select")
#additionnal fields dans occtax MET 28/09/2020
additional_fields = DB.Column(JSONB)
t_occurrences_occtax = relationship(
"TOccurrencesOccurrence", lazy="joined", cascade="all, delete-orphan"
)
observers = DB.relationship(
User,
lazy="joined",
secondary=corRoleRelevesOccurrence.__table__,
primaryjoin=(corRoleRelevesOccurrence.id_releve_occtax == id_releve_occtax),
secondaryjoin=(corRoleRelevesOccurrence.id_role == User.id_role),
foreign_keys=[
corRoleRelevesOccurrence.id_releve_occtax,
corRoleRelevesOccurrence.id_role,
],
)
digitiser = relationship(
User,
lazy="joined",
primaryjoin=(User.id_role == id_digitiser),
foreign_keys=[id_digitiser],
)
dataset = relationship(
TDatasets,
lazy="joined",
primaryjoin=(TDatasets.id_dataset == id_dataset),
foreign_keys=[id_dataset],
)
readonly_fields = ["id_releve_occtax", "t_occurrences_occtax", "observers"]
def get_geofeature(self, recursif=True, relationships=()):
return self.as_geofeature("geom_4326", "id_releve_occtax", recursif, relationships=relationships)
class Synthese(DB.Model):
__tablename__ = "synthese"
__table_args__ = {"schema": "gn_synthese"}
id_synthese = DB.Column(DB.Integer, primary_key=True)
unique_id_sinp = DB.Column(UUID(as_uuid=True))
unique_id_sinp_grp = DB.Column(UUID(as_uuid=True))
id_source = DB.Column(DB.Integer)
entity_source_pk_value = DB.Column(DB.Integer)
id_dataset = DB.Column(DB.Integer)
id_nomenclature_grp_typ = DB.Column(DB.Integer)
grp_method = DB.Column(DB.Unicode)
id_nomenclature_obs_technique = DB.Column(DB.Integer)
id_nomenclature_bio_status = DB.Column(DB.Integer)
id_nomenclature_bio_condition = DB.Column(DB.Integer)
id_nomenclature_naturalness = DB.Column(DB.Integer)
id_nomenclature_exist_proof = DB.Column(DB.Integer)
id_nomenclature_valid_status = DB.Column(DB.Integer)
id_nomenclature_diffusion_level = DB.Column(DB.Integer)
id_nomenclature_life_stage = DB.Column(DB.Integer)
id_nomenclature_sex = DB.Column(DB.Integer)
id_nomenclature_obj_count = DB.Column(DB.Integer)
id_nomenclature_type_count = DB.Column(DB.Integer)
id_nomenclature_sensitivity = DB.Column(DB.Integer)
id_nomenclature_observation_status = DB.Column(DB.Integer)
id_nomenclature_blurring = DB.Column(DB.Integer)
id_nomenclature_source_status = DB.Column(DB.Integer)
id_nomenclature_behaviour = DB.Column(DB.Integer)
count_min = DB.Column(DB.Integer)
count_max = DB.Column(DB.Integer)
cd_nom = DB.Column(DB.Integer)
nom_cite = DB.Column(DB.Unicode)
meta_v_taxref = DB.Column(DB.Unicode)
sample_number_proof = DB.Column(DB.Unicode)
digital_proof = DB.Column(DB.Unicode)
non_digital_proof = DB.Column(DB.Unicode)
altitude_min = DB.Column(DB.Integer)
altitude_max = DB.Column(DB.Integer)
depth_min = DB.Column(DB.Integer)
depth_max = DB.Column(DB.Integer)
precision = DB.Column(DB.Integer)
the_geom_4326 = DB.Column(Geometry("GEOMETRY", 4326))
the_geom_point = DB.Column(Geometry("GEOMETRY", 4326))
the_geom_local = DB.Column(
Geometry("GEOMETRY", current_app.config["LOCAL_SRID"]))
place_name = DB.Column(DB.Unicode)
date_min = DB.Column(DB.DateTime)
date_max = DB.Column(DB.DateTime)
validator = DB.Column(DB.Unicode)
validation_comment = DB.Column(DB.Unicode)
observers = DB.Column(DB.Unicode)
determiner = DB.Column(DB.Unicode)
id_digitiser = DB.Column(DB.Integer)
id_nomenclature_determination_method = DB.Column(DB.Integer)
comment_context = DB.Column(DB.Unicode)
comment_description = DB.Column(DB.Unicode)
additional_data = DB.Column(JSONB)
meta_validation_date = DB.Column(DB.DateTime)
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
last_action = DB.Column(DB.Unicode)
def get_geofeature(self, recursif=True, columns=None):
return self.as_geofeature("the_geom_4326",
"id_synthese",
recursif,
columns=columns)
class VReleveOccurrence(ReleveModel):
__tablename__ = "v_releve_occtax"
__table_args__ = {"schema": "pr_occtax"}
id_releve_occtax = DB.Column(DB.Integer)
id_dataset = DB.Column(DB.Integer)
id_digitiser = DB.Column(DB.Integer)
date_min = DB.Column(DB.DateTime)
date_max = DB.Column(DB.DateTime)
altitude_min = DB.Column(DB.Integer)
altitude_max = DB.Column(DB.Integer)
depth_min = DB.Column(DB.Integer)
depth_max = DB.Column(DB.Integer)
place_name = DB.Column(DB.Unicode)
meta_device_entry = DB.Column(DB.Unicode)
comment = DB.Column(DB.Unicode)
geom_4326 = DB.Column(Geometry("GEOMETRY", 4326))
id_occurrence_occtax = DB.Column(DB.Integer, primary_key=True)
cd_nom = DB.Column(DB.Integer)
nom_cite = DB.Column(DB.Unicode)
lb_nom = DB.Column(DB.Unicode)
nom_valide = DB.Column(DB.Unicode)
nom_vern = DB.Column(DB.Unicode)
leaflet_popup = DB.Column(DB.Unicode)
observateurs = DB.Column(DB.Unicode)
observers = DB.relationship(
User,
secondary=corRoleRelevesOccurrence.__table__,
primaryjoin=(corRoleRelevesOccurrence.id_releve_occtax == id_releve_occtax),
secondaryjoin=(corRoleRelevesOccurrence.id_role == User.id_role),
foreign_keys=[
corRoleRelevesOccurrence.id_releve_occtax,
corRoleRelevesOccurrence.id_role,
],
)
def get_geofeature(self, recursif=True):
return self.as_geofeature("geom_4326", "id_occurrence_occtax", recursif)
class VSyntheseForWebApp(DB.Model):
__tablename__ = "v_synthese_for_web_app"
__table_args__ = {"schema": "gn_synthese"}
id_synthese = DB.Column(
DB.Integer,
ForeignKey("gn_synthese.v_synthese_decode_nomenclatures.id_synthese"),
primary_key=True,
)
unique_id_sinp = DB.Column(UUID(as_uuid=True))
unique_id_sinp_grp = DB.Column(UUID(as_uuid=True))
id_source = DB.Column(DB.Integer)
entity_source_pk_value = DB.Column(DB.Integer)
id_dataset = DB.Column(DB.Integer)
dataset_name = DB.Column(DB.Integer)
id_acquisition_framework = DB.Column(DB.Integer)
count_min = DB.Column(DB.Integer)
count_max = DB.Column(DB.Integer)
cd_nom = DB.Column(DB.Integer)
cd_ref = DB.Column(DB.Unicode)
nom_cite = DB.Column(DB.Unicode)
nom_valide = DB.Column(DB.Unicode)
nom_vern = DB.Column(DB.Unicode)
lb_nom = DB.Column(DB.Unicode)
meta_v_taxref = DB.Column(DB.Unicode)
sample_number_proof = DB.Column(DB.Unicode)
digital_proof = DB.Column(DB.Unicode)
non_digital_proof = DB.Column(DB.Unicode)
altitude_min = DB.Column(DB.Integer)
altitude_max = DB.Column(DB.Integer)
depth_min = DB.Column(DB.Integer)
depth_max = DB.Column(DB.Integer)
place_name = DB.Column(DB.Unicode)
the_geom_4326 = DB.Column(Geometry("GEOMETRY", 4326))
date_min = DB.Column(DB.DateTime)
date_max = DB.Column(DB.DateTime)
validator = DB.Column(DB.Unicode)
validation_comment = DB.Column(DB.Unicode)
observers = DB.Column(DB.Unicode)
determiner = DB.Column(DB.Unicode)
id_digitiser = DB.Column(DB.Integer)
comment_context = DB.Column(DB.Unicode)
comment_description = DB.Column(DB.Unicode)
meta_validation_date = DB.Column(DB.DateTime)
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
last_action = DB.Column(DB.Unicode)
id_nomenclature_geo_object_nature = DB.Column(DB.Integer)
id_nomenclature_info_geo_type = DB.Column(DB.Integer)
id_nomenclature_grp_typ = DB.Column(DB.Integer)
grp_method = DB.Column(DB.Unicode)
id_nomenclature_obs_technique = DB.Column(DB.Integer)
id_nomenclature_bio_status = DB.Column(DB.Integer)
id_nomenclature_bio_condition = DB.Column(DB.Integer)
id_nomenclature_naturalness = DB.Column(DB.Integer)
id_nomenclature_exist_proof = DB.Column(DB.Integer)
id_nomenclature_valid_status = DB.Column(DB.Integer)
id_nomenclature_diffusion_level = DB.Column(DB.Integer)
id_nomenclature_life_stage = DB.Column(DB.Integer)
id_nomenclature_sex = DB.Column(DB.Integer)
id_nomenclature_obj_count = DB.Column(DB.Integer)
id_nomenclature_type_count = DB.Column(DB.Integer)
id_nomenclature_sensitivity = DB.Column(DB.Integer)
id_nomenclature_observation_status = DB.Column(DB.Integer)
id_nomenclature_blurring = DB.Column(DB.Integer)
id_nomenclature_source_status = DB.Column(DB.Integer)
id_nomenclature_valid_status = DB.Column(DB.Integer)
id_nomenclature_behaviour = DB.Column(DB.Integer)
reference_biblio = DB.Column(DB.Unicode)
name_source = DB.Column(DB.Unicode)
url_source = DB.Column(DB.Unicode)
st_asgeojson = DB.Column(DB.Unicode)
def get_geofeature(self, recursif=False, columns=()):
return self.as_geofeature("the_geom_4326",
"id_synthese",
recursif,
columns=columns)
def get_app(config, _app=None, with_external_mods=True, with_flask_admin=True):
# Make sure app is a singleton
if _app is not None:
return _app
app = Flask(__name__)
app.config.update(config)
# Bind app to DB
DB.init_app(app)
# pour la suppression des fichier sur un delete de media
@before_models_committed.connect_via(app)
def on_before_models_committed(sender, changes):
for obj, change in changes:
if change == "delete" and hasattr(obj, "__before_commit_delete__"):
obj.__before_commit_delete__()
# Bind app to MA
MA.init_app(app)
# pass parameters to the usershub authenfication sub-module, DONT CHANGE THIS
app.config["DB"] = DB
# pass parameters to the submodules
app.config["MA"] = MA
# pass the ID_APP to the submodule to avoid token conflict between app on the same server
app.config["ID_APP"] = app.config["ID_APPLICATION_GEONATURE"]
with app.app_context():
if app.config["MAIL_ON_ERROR"] and app.config["MAIL_CONFIG"]:
from geonature.utils.logs import mail_handler
logging.getLogger().addHandler(mail_handler)
# DB.create_all()
if with_flask_admin:
# from geonature.core.admin import flask_admin
from geonature.core.admin.admin import flask_admin
from pypnusershub.routes import routes
app.register_blueprint(routes, url_prefix="/auth")
from pypn_habref_api.routes import routes
app.register_blueprint(routes, url_prefix="/habref")
from pypnusershub import routes_register
app.register_blueprint(routes_register.bp, url_prefix="/pypn/register")
from pypnnomenclature.routes import routes
app.register_blueprint(routes, url_prefix="/nomenclatures")
from geonature.core.gn_permissions.routes import routes
app.register_blueprint(routes, url_prefix="/permissions")
from geonature.core.gn_permissions.backoffice.views import routes
app.register_blueprint(routes, url_prefix="/permissions_backoffice")
from geonature.core.routes import routes
app.register_blueprint(routes, url_prefix="")
from geonature.core.users.routes import routes
app.register_blueprint(routes, url_prefix="/users")
from geonature.core.gn_synthese.routes import routes
app.register_blueprint(routes, url_prefix="/synthese")
from geonature.core.gn_meta.routes import routes
app.register_blueprint(routes, url_prefix="/meta")
from geonature.core.ref_geo.routes import routes
app.register_blueprint(routes, url_prefix="/geo")
from geonature.core.gn_exports.routes import routes
app.register_blueprint(routes, url_prefix="/exports")
from geonature.core.auth.routes import routes
app.register_blueprint(routes, url_prefix="/gn_auth")
from geonature.core.gn_monitoring.routes import routes
app.register_blueprint(routes, url_prefix="/gn_monitoring")
from geonature.core.gn_commons.routes import routes
app.register_blueprint(routes, url_prefix="/gn_commons")
# errors
from geonature.core.errors import routes
app.wsgi_app = ReverseProxied(app.wsgi_app,
script_name=config["API_ENDPOINT"])
CORS(app, supports_credentials=True)
# Configuration des mails
if app.config["MAIL_CONFIG"]:
conf = app.config.copy()
conf.update(app.config["MAIL_CONFIG"])
app.config = conf
MAIL.init_app(app)
# Chargement des mosdules tiers
if with_external_mods:
for conf, manifest, module in list_and_import_gn_modules(app):
app.register_blueprint(module.backend.blueprint.blueprint,
url_prefix=conf["MODULE_URL"])
_app = app
return app
class DefaultNomenclaturesValue(DB.Model):
__tablename__ = "defaults_nomenclatures_value"
__table_args__ = {"schema": "pr_occhab"}
mnemonique_type = DB.Column(DB.Integer, primary_key=True)
id_organism = DB.Column(DB.Integer, primary_key=True)
id_nomenclature = DB.Column(DB.Integer, primary_key=True)
class TDatasets(DB.Model):
__tablename__ = "t_datasets"
__table_args__ = {"schema": "gn_meta"}
id_dataset = DB.Column(DB.Integer, primary_key=True)
unique_dataset_id = DB.Column(UUID(as_uuid=True),
default=select([func.uuid_generate_v4()]))
id_acquisition_framework = DB.Column(
DB.Integer,
ForeignKey(
"gn_meta.t_acquisition_frameworks.id_acquisition_framework"),
)
dataset_name = DB.Column(DB.Unicode)
dataset_shortname = DB.Column(DB.Unicode)
dataset_desc = DB.Column(DB.Unicode)
id_nomenclature_data_type = DB.Column(
DB.Integer,
default=TNomenclatures.get_default_nomenclature("DATA_TYP"))
keywords = DB.Column(DB.Unicode)
marine_domain = DB.Column(DB.Boolean)
terrestrial_domain = DB.Column(DB.Boolean)
id_nomenclature_dataset_objectif = DB.Column(
DB.Integer,
default=TNomenclatures.get_default_nomenclature("JDD_OBJECTIFS"))
bbox_west = DB.Column(DB.Float)
bbox_east = DB.Column(DB.Float)
bbox_south = DB.Column(DB.Float)
bbox_north = DB.Column(DB.Float)
id_nomenclature_collecting_method = DB.Column(
DB.Integer,
default=TNomenclatures.get_default_nomenclature("METHO_RECUEIL"))
id_nomenclature_data_origin = DB.Column(
DB.Integer,
default=TNomenclatures.get_default_nomenclature("DS_PUBLIQUE"))
id_nomenclature_source_status = DB.Column(
DB.Integer,
default=TNomenclatures.get_default_nomenclature("STATUT_SOURCE"))
id_nomenclature_resource_type = DB.Column(
DB.Integer,
default=TNomenclatures.get_default_nomenclature("RESOURCE_TYP"))
default_validity = DB.Column(DB.Boolean)
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
active = DB.Column(DB.Boolean, default=True)
cor_dataset_actor = relationship(
CorDatasetActor,
lazy="select",
cascade="save-update, merge, delete, delete-orphan",
)
@staticmethod
def get_id(uuid_dataset):
id_dataset = (DB.session.query(TDatasets.id_dataset).filter(
TDatasets.unique_dataset_id == uuid_dataset).first())
if id_dataset:
return id_dataset[0]
return id_dataset
@staticmethod
def get_uuid(id_dataset):
uuid_dataset = (DB.session.query(TDatasets.unique_dataset_id).filter(
TDatasets.id_dataset == id_dataset).first())
if uuid_dataset:
return uuid_dataset[0]
return uuid_dataset
@staticmethod
def get_user_datasets(user):
"""get the dataset(s) where the user is actor (himself or with its organism)
param: user from TRole model
return: a list of id_dataset """
q = DB.session.query(CorDatasetActor, CorDatasetActor.id_dataset)
if user.id_organisme is None:
q = q.filter(CorDatasetActor.id_role == user.id_role)
else:
q = q.filter(
or_(
CorDatasetActor.id_organism == user.id_organisme,
CorDatasetActor.id_role == user.id_role,
))
return list(set([d.id_dataset for d in q.all()]))
class TStationsOcchab(ReleveCruvedAutorization):
__tablename__ = "t_stations"
__table_args__ = {"schema": "pr_occhab"}
id_station = DB.Column(DB.Integer, primary_key=True)
unique_id_sinp_station = DB.Column(UUID(as_uuid=True),
default=select(
[func.uuid_generate_v4()]))
id_dataset = DB.Column(DB.Integer,
ForeignKey('gn_meta.t_datasets.id_dataset'))
date_min = DB.Column(DB.DateTime)
date_max = DB.Column(DB.DateTime)
observers_txt = DB.Column(DB.Unicode)
station_name = DB.Column(DB.Unicode)
is_habitat_complex = DB.Column(DB.Boolean)
id_nomenclature_exposure = DB.Column(
DB.Integer, ForeignKey(TNomenclatures.id_nomenclature))
altitude_min = DB.Column(DB.Integer)
altitude_max = DB.Column(DB.Integer)
depth_min = DB.Column(DB.Integer)
depth_max = DB.Column(DB.Integer)
area = DB.Column(DB.Float)
id_nomenclature_area_surface_calculation = DB.Column(
DB.Integer, ForeignKey(TNomenclatures.id_nomenclature))
id_nomenclature_geographic_object = DB.Column(
DB.Integer, ForeignKey(TNomenclatures.id_nomenclature))
comment = DB.Column(DB.Unicode)
id_digitiser = DB.Column(DB.Integer)
geom_4326 = DB.Column(Geometry("GEOMETRY", 4626))
t_habitats = relationship("THabitatsOcchab",
lazy="joined",
cascade="all, delete-orphan")
dataset = relationship("TDatasets", lazy="joined")
observers = DB.relationship(
User,
lazy="joined",
secondary=CorStationObserverOccHab.__table__,
primaryjoin=(CorStationObserverOccHab.id_station == id_station),
secondaryjoin=(CorStationObserverOccHab.id_role == User.id_role),
foreign_keys=[
CorStationObserverOccHab.id_station,
CorStationObserverOccHab.id_role,
],
)
# overright the constructor
# to inherit of ReleModel, the constructor must define some mandatory attribute
def __init__(self, *args, **kwargs):
super(TStationsOcchab, self).__init__(*args, **kwargs)
self.observer_rel = getattr(self, 'observers')
self.dataset_rel = getattr(self, 'dataset')
self.id_digitiser_col = getattr(self, 'id_digitiser')
self.id_dataset_col = getattr(self, 'id_dataset')
def get_geofeature(self, recursif=True):
return self.as_geofeature("geom_4326",
"id_station",
recursif,
relationships=[
'observers',
't_habitats',
'habref',
'dataset',
])
class TAcquisitionFramework(DB.Model):
__tablename__ = "t_acquisition_frameworks"
__table_args__ = {"schema": "gn_meta"}
id_acquisition_framework = DB.Column(DB.Integer, primary_key=True)
unique_acquisition_framework_id = DB.Column(UUID(as_uuid=True),
default=select(
[func.uuid_generate_v4()]))
acquisition_framework_name = DB.Column(DB.Unicode)
acquisition_framework_desc = DB.Column(DB.Unicode)
id_nomenclature_territorial_level = DB.Column(DB.Integer)
territory_desc = DB.Column(DB.Unicode)
keywords = DB.Column(DB.Unicode)
id_nomenclature_financing_type = DB.Column(DB.Integer)
target_description = DB.Column(DB.Unicode)
ecologic_or_geologic_target = DB.Column(DB.Unicode)
acquisition_framework_parent_id = DB.Column(DB.Integer)
is_parent = DB.Column(DB.Boolean)
acquisition_framework_start_date = DB.Column(DB.DateTime)
acquisition_framework_end_date = DB.Column(DB.DateTime)
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
cor_af_actor = relationship(
CorAcquisitionFrameworkActor,
lazy="select",
cascade="save-update, merge, delete, delete-orphan",
)
cor_objectifs = DB.relationship(
TNomenclatures,
secondary=CorAcquisitionFrameworkObjectif.__table__,
primaryjoin=(CorAcquisitionFrameworkObjectif.id_acquisition_framework
== id_acquisition_framework),
secondaryjoin=(CorAcquisitionFrameworkObjectif.id_nomenclature_objectif
== TNomenclatures.id_nomenclature),
foreign_keys=[
CorAcquisitionFrameworkObjectif.id_acquisition_framework,
CorAcquisitionFrameworkObjectif.id_nomenclature_objectif,
],
lazy="select",
)
cor_volets_sinp = DB.relationship(
TNomenclatures,
secondary=CorAcquisitionFrameworkVoletSINP.__table__,
primaryjoin=(CorAcquisitionFrameworkVoletSINP.id_acquisition_framework
== id_acquisition_framework),
secondaryjoin=(
CorAcquisitionFrameworkVoletSINP.id_nomenclature_voletsinp ==
TNomenclatures.id_nomenclature),
foreign_keys=[
CorAcquisitionFrameworkVoletSINP.id_acquisition_framework,
CorAcquisitionFrameworkVoletSINP.id_nomenclature_voletsinp,
],
lazy="select",
)
@staticmethod
def get_id(uuid_af):
"""
return the acquisition framework's id
from its UUID if exist or None
"""
a_f = (DB.session.query(
TAcquisitionFramework.id_acquisition_framework).filter(
TAcquisitionFramework.unique_acquisition_framework_id ==
uuid_af).first())
if a_f:
return a_f[0]
return a_f
class CorImportArchives(DB.Model):
__tablename__ = "cor_import_archives"
__table_args__ = {"schema": "gn_import_archives", "extend_existing": True}
id_import = DB.Column(DB.Integer, primary_key=True)
table_archive = DB.Column(DB.Integer, primary_key=True)
class TModules(DB.Model):
__tablename__ = "t_modules"
__table_args__ = {"schema": "gn_commons"}
id_module = DB.Column(DB.Integer, primary_key=True)
module_code = DB.Column(DB.Unicode)
module_label = DB.Column(DB.Unicode)
module_picto = DB.Column(DB.Unicode)
module_desc = DB.Column(DB.Unicode)
module_group = DB.Column(DB.Unicode)
module_path = DB.Column(DB.Unicode)
module_external_url = DB.Column(DB.Unicode)
module_target = DB.Column(DB.Unicode)
module_comment = DB.Column(DB.Unicode)
active_frontend = DB.Column(DB.Boolean)
active_backend = DB.Column(DB.Boolean)
module_doc_url = DB.Column(DB.Unicode)
class TImports(DB.Model):
__tablename__ = "t_imports"
__table_args__ = {"schema": "gn_imports", "extend_existing": True}
id_import = DB.Column(DB.Integer, primary_key=True, autoincrement=True)
format_source_file = DB.Column(DB.Unicode, nullable=True)
srid = DB.Column(DB.Integer, nullable=True)
separator = DB.Column(DB.Unicode, nullable=True)
encoding = DB.Column(DB.Unicode, nullable=True)
import_table = DB.Column(DB.Unicode, nullable=True)
full_file_name = DB.Column(DB.Unicode, nullable=True)
id_dataset = DB.Column(DB.Integer, ForeignKey("gn_meta.t_datasets.id_dataset"), nullable=True)
id_field_mapping = DB.Column(DB.Integer, nullable=True)
id_content_mapping = DB.Column(DB.Integer, nullable=True)
date_create_import = DB.Column(DB.DateTime, nullable=True)
date_update_import = DB.Column(DB.DateTime, nullable=True)
date_end_import = DB.Column(DB.DateTime, nullable=True)
source_count = DB.Column(DB.Integer, nullable=True)
import_count = DB.Column(DB.Integer, nullable=True)
taxa_count = DB.Column(DB.Integer, nullable=True)
date_min_data = DB.Column(DB.DateTime, nullable=True)
date_max_data = DB.Column(DB.DateTime, nullable=True)
step = DB.Column(DB.Integer, nullable=True)
uuid_autogenerated = DB.Column(DB.Boolean)
altitude_autogenerated = DB.Column(DB.Boolean)
author = DB.relationship(
User,
lazy="joined",
secondary=CorRoleImport.__table__,
primaryjoin=(CorRoleImport.id_import == id_import),
secondaryjoin=(CorRoleImport.id_role == User.id_role),
foreign_keys=[CorRoleImport.id_import, CorRoleImport.id_role],
)
is_finished = DB.Column(DB.Boolean, nullable=False, default=False)
processing = DB.Column(DB.Boolean, nullable=False, default=False)
in_error = DB.Column(DB.Boolean)
errors = DB.relationship(
"VUserImportsErrors", lazy="joined", order_by="VUserImportsErrors.error_type"
)
dataset = DB.relationship("TDatasets", lazy="joined")
def to_dict(self):
import_as_dict = self.as_dict(True)
if import_as_dict["date_end_import"] is None:
import_as_dict["date_end_import"] = "En cours"
import_as_dict["author_name"] = "; ".join(
[a.nom_role + " " + a.prenom_role for a in self.author]
)
import_as_dict["dataset_name"] = import_as_dict["dataset"]["dataset_name"]
import_as_dict.pop("dataset")
import_as_dict["errors"] = import_as_dict.get("errors", [])
name_source = "Import(id=" + str(self.id_import) + ")"
id_source = None
source = (
DB.session.query(TSources.id_source)
.filter(TSources.name_source == name_source)
.first()
)
if source:
id_source = source[0]
import_as_dict["id_source"] = id_source
return import_as_dict
from pypnusershub.db.models import User
from utils_flask_sqla.serializers import serializable
from geonature.utils.utilssqlalchemy import geoserializable
from geonature.utils.env import DB
from geonature.core.gn_commons.models import TModules
from geonature.core.gn_meta.models import TDatasets
corVisitObserver = DB.Table(
"cor_visit_observer",
DB.MetaData(schema="gn_monitoring"),
DB.Column(
"id_base_visit",
DB.Integer,
ForeignKey("gn_monitoring.cor_visit_observer.id_base_visit"),
primary_key=True,
),
DB.Column(
"id_role",
DB.Integer,
# ForeignKey("utilisateurs.t_roles.id_role"),
primary_key=True,
),
)
corSiteModule = DB.Table(
"cor_site_module",
DB.MetaData(schema="gn_monitoring"),
DB.Column(
"id_base_site",
DB.Integer,
ForeignKey("gn_monitoring.cor_site_module.id_base_site"),
