class TArbresMesures (DB.Model):
__tablename__ = "t_arbres_mesures"
__table_args__ = {'schema': SCHEMA}
id_arbre_mesure = DB.Column('id_arbre_mesure', DB.Integer, primary_key = True)
id_arbre = DB.Column('id_arbre', DB.Integer, DB.ForeignKey('pr_psdrf.t_arbres.id_arbre'))
id_cycle = DB.Column('id_cycle', DB.Integer, DB.ForeignKey('pr_psdrf.t_cycles.id_cycle'))
diametre1 = DB.Column('diametre1', DB.Float)
diametre2 = DB.Column('diametre2', DB.Float)
type = DB.Column('type', DB.String)
hauteur_totale = DB.Column('hauteur_totale', DB.Float)
hauteur_branche = DB.Column('hauteur_branche', DB.Float)
stade_durete = DB.Column('stade_durete', DB.Integer)
stade_ecorce = DB.Column('stade_ecorce', DB.Integer)
liane = DB.Column('liane', DB.String)
diametre_liane = DB.Column('diametre_liane', DB.Float)
coupe = DB.Column('coupe', DB.Unicode)
limite = DB.Column('limite', DB.Boolean)
id_nomenclature_code_sanitaire = DB.Column('id_nomenclature_code_sanitaire', DB.Integer)
code_ecolo = DB.Column('code_ecolo', DB.String)
ref_code_ecolo = DB.Column('ref_code_ecolo', DB.String)
ratio_hauteur = DB.Column('ratio_hauteur', DB.Boolean)
observation = DB.deferred(DB.Column('observation', DB.Text))
arbre = DB.relationship('TArbres', foreign_keys=id_arbre)
cycle = DB.relationship('TCycles', foreign_keys=id_cycle)
class OneStation(TStationsOcchab):
exposure = DB.relationship(
TNomenclatures,
primaryjoin=(TNomenclatures.id_nomenclature ==
TStationsOcchab.id_nomenclature_exposure),
)
area_surface_calculation = DB.relationship(
TNomenclatures,
primaryjoin=(TNomenclatures.id_nomenclature ==
TStationsOcchab.id_nomenclature_area_surface_calculation),
)
geographic_object = DB.relationship(
TNomenclatures,
primaryjoin=(TNomenclatures.id_nomenclature ==
TStationsOcchab.id_nomenclature_geographic_object),
)
t_one_habitats = relationship("OneHabitat", lazy="select")
def get_geofeature(self, recursif=True):
return self.as_geofeature(
"geom_4326",
"id_station",
True,
relationships=[
'observers', 't_one_habitats', 'exposure', 'dataset',
'area_surface_calculation', 'geographic_object',
'determination_method', 'collection_technique', 'abundance',
"habref"
])
class TMonitoringVisits(TBaseVisits):
__tablename__ = "t_visit_complements"
__table_args__ = {"schema": "gn_monitoring"}
__mapper_args__ = {
'polymorphic_identity': 'monitoring_visit',
}
id_base_visit = DB.Column(
DB.ForeignKey('gn_monitoring.t_base_visits.id_base_visit'),
nullable=False,
primary_key=True)
data = DB.Column(JSONB)
medias = DB.relationship(
TMedias,
lazy='joined',
primaryjoin=(TMedias.uuid_attached_row == TBaseVisits.uuid_base_visit),
foreign_keys=[TMedias.uuid_attached_row])
observers = DB.relationship(User,
lazy='joined',
secondary=corVisitObserver)
observations = DB.relation(
"TMonitoringObservations",
lazy='select',
primaryjoin=(TObservations.id_base_visit == TBaseVisits.id_base_visit),
foreign_keys=[TObservations.id_base_visit],
cascade="all,delete")
nb_observations = column_property(
select([func.count(TObservations.id_base_visit)]).\
where(TObservations.id_base_visit==id_base_visit)
)
class InfoSite(DB.Model):
'''
Informations propres aux problématiques chiro pour un site donné
'''
__tablename__ = 't_site_infos'
__table_args__ = {'schema': 'monitoring_chiro'}
id_base_site = DB.Column(DB.Integer,
ForeignKey(TBaseSites.id_base_site),
primary_key=True)
base_site = DB.relationship(TBaseSites)
description = DB.Column(DB.UnicodeText)
# rel nomenclature
id_nomenclature_frequentation = DB.Column(DB.Integer)
menace_cmt = DB.Column(DB.Unicode(250))
actions = DB.Column(DB.Unicode(250))
menaces_ids = DB.relationship(RelChirositeTNomenclaturesMenace,
lazy='joined',
passive_updates=False)
amenagements_ids = DB.relationship(RelChirositeTNomenclaturesAmenagement,
lazy='joined',
passive_updates=False)
site_actif = DB.Column(DB.Boolean, default=False)
contact_nom = DB.Column(DB.Unicode(25))
contact_prenom = DB.Column(DB.Unicode(25))
contact_adresse = DB.Column(DB.Unicode(150))
contact_code_postal = DB.Column(DB.Unicode(5))
contact_ville = DB.Column(DB.Unicode(100))
contact_telephone = DB.Column(DB.Unicode(15))
contact_portable = DB.Column(DB.Unicode(15))
contact_commentaire = DB.Column(DB.Unicode(250))
class TMonitoringModules(TModules):
__tablename__ = 't_module_complements'
__table_args__ = {'schema': 'gn_monitoring'}
__mapper_args__ = {
'polymorphic_identity': 'monitoring_module',
}
id_module = DB.Column(DB.ForeignKey('gn_commons.t_modules.id_module'),
primary_key=True,
nullable=False,
unique=True)
uuid_module_complement = DB.Column(UUID(as_uuid=True), default=uuid4)
medias = DB.relationship(
TMedias,
primaryjoin=(TMedias.uuid_attached_row == uuid_module_complement),
foreign_keys=[TMedias.uuid_attached_row])
sites = DB.relationship(
'TMonitoringSites',
secondary='gn_monitoring.cor_site_module',
primaryjoin=id_module == CorSiteModule.id_module,
secondaryjoin=TMonitoringSites.id_base_site ==
CorSiteModule.id_base_site,
join_depth=0,
lazy="select",
# backref='parents'
)
class ContactTaxon(DB.Model):
'''
Informations recueillies sur un taxon donné lors d'une visite
'''
__tablename__ = 't_visite_contact_taxons'
__table_args__ = {'schema': 'monitoring_chiro'}
id_contact_taxon = DB.Column(DB.Integer, primary_key=True)
id_base_visit = DB.Column(DB.Integer,
ForeignKey(TBaseVisits.id_base_visit))
tx_presume = DB.Column(DB.Unicode(250))
cd_nom = DB.Column(DB.Integer)
nom_complet = DB.Column(DB.Unicode(250))
espece_incertaine = DB.Column(DB.Boolean, default=False)
id_nomenclature_behaviour = DB.Column(DB.Integer)
id_nomenclature_preuve_repro = DB.Column(DB.Integer)
id_nomenclature_bio_condition = DB.Column(DB.Integer)
id_nomenclature_observation_status = DB.Column(DB.Integer)
indices_cmt = DB.Column(DB.Unicode(250))
commentaire = DB.Column(DB.Unicode(250))
id_digitiser = DB.Column(DB.Integer)
uuid_chiro_visite_contact_taxon = DB.Column(UUID(as_uuid=True),
default=select(
[func.uuid_generate_v4()]))
denombrements = DB.relationship("CountingContact",
cascade="all, delete-orphan")
indices = DB.relationship(RelContactTaxonIndices,
lazy='joined',
cascade="all, delete-orphan")
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("utilisateurs.t_roles.id_role"))
id_organism = DB.Column(
DB.Integer, ForeignKey("utilisateurs.bib_organismes.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,
primaryjoin=(
TNomenclatures.id_nomenclature == id_nomenclature_actor_role),
)
role = DB.relationship(User,
primaryjoin=(User.id_role == id_role),
foreign_keys=[id_role])
organism = relationship("BibOrganismes", foreign_keys=[id_organism])
@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 TMonitoringSites(TBaseSites):
__tablename__ = 't_site_complements'
__table_args__ = {'schema': 'gn_monitoring'}
__mapper_args__ = {
'polymorphic_identity': 'monitoring_site',
}
id_base_site = DB.Column(
DB.ForeignKey('gn_monitoring.t_base_sites.id_base_site'),
nullable=False,
primary_key=True)
id_module = DB.Column(
DB.ForeignKey('gn_commons.t_modules.id_module'),
nullable=False,
)
id_sites_group = DB.Column(
DB.ForeignKey('gn_monitoring.t_sites_groups.id_sites_group',
# ondelete='SET NULL'
),
nullable=False,
)
data = DB.Column(JSONB)
visits = DB.relationship(
TMonitoringVisits,
lazy="select",
primaryjoin=(TBaseSites.id_base_site == TBaseVisits.id_base_site),
foreign_keys=[TBaseVisits.id_base_site],
cascade="all,delete")
medias = DB.relationship(
TMedias,
lazy='joined',
primaryjoin=(TMedias.uuid_attached_row == TBaseSites.uuid_base_site),
foreign_keys=[TMedias.uuid_attached_row],
cascade="all",
)
last_visit = column_property(
select([func.max(TBaseVisits.visit_date_min)]).\
where(TBaseVisits.id_base_site==id_base_site)
)
nb_visits = column_property(
select([func.count(TBaseVisits.id_base_site)]).\
where(TBaseVisits.id_base_site==id_base_site)
)
geom_geojson = column_property(
select([func.st_asgeojson(TBaseSites.geom)]).\
where(TBaseSites.id_base_site==id_base_site).\
correlate_except(TBaseSites)
)
class TRegroupementsEssences (DB.Model):
__tablename__ = "t_regroupements_essences"
__table_args__ = {'schema': SCHEMA}
id_dispositif = DB.Column('id_dispositif', DB.Integer, DB.ForeignKey('pr_psdrf.t_dispositifs.id_dispositif'), primary_key = True)
code_essence = DB.Column('code_essence', DB.String, DB.ForeignKey('pr_psdrf.bib_essences.code_essence'), primary_key = True)
code_regroupement = DB.Column('code_regroupement', DB.String)
couleur = DB.Column('couleur', DB.String)
essence = DB.relationship('BibEssences', foreign_keys=code_essence)
dispositif = DB.relationship('TDispositifs', foreign_keys=id_dispositif)
class TDispositifs (DB.Model):
__tablename__ = "t_dispositifs"
__table_args__ = {'schema': SCHEMA}
id_dispositif = DB.Column('id_dispositif', DB.Integer, primary_key = True)
name = DB.Column('name', DB.String)
id_organisme = DB.Column('id_organisme', DB.Integer, DB.ForeignKey('utilisateurs.bib_organismes.id_organisme'))
alluvial = DB.Column('alluvial', DB.Boolean)
organisme = DB.relationship('BibOrganismes')
placettes = DB.relationship('TPlacettes', back_populates='dispositif')
municipalities = DB.relationship('LiMunicipalities', secondary=dispositifs_municipalities_assoc)
areas = DB.relationship('LAreas', secondary=dispositifs_area_assoc)
class TMonitoringModules(TModules):
__tablename__ = 't_module_complements'
__table_args__ = {'schema': 'gn_monitoring'}
__mapper_args__ = {
'polymorphic_identity': 'monitoring_module',
}
id_module = DB.Column(DB.ForeignKey('gn_commons.t_modules.id_module'),
primary_key=True,
nullable=False,
unique=True)
uuid_module_complement = DB.Column(UUID(as_uuid=True), default=uuid4)
id_list_observer = DB.Column(DB.Integer)
id_list_taxonomy = DB.Column(DB.Integer)
taxonomy_display_field_name = DB.Column(DB.Unicode)
b_synthese = DB.Column(DB.Boolean)
medias = DB.relationship(
TMedias,
primaryjoin=(TMedias.uuid_attached_row == uuid_module_complement),
foreign_keys=[TMedias.uuid_attached_row],
lazy='joined')
sites = DB.relationship(
'TMonitoringSites',
uselist=True, # pourquoi pas par defaut ?
primaryjoin=TMonitoringSites.id_module == id_module,
foreign_keys=[id_module],
lazy="select",
)
sites_groups = DB.relationship(
'TMonitoringSitesGroups',
uselist=True, # pourquoi pas par defaut ?
primaryjoin=TMonitoringSitesGroups.id_module == id_module,
foreign_keys=[id_module],
lazy="select",
)
datasets = DB.relationship(
'TDatasets',
secondary='gn_commons.cor_module_dataset',
secondaryjoin=TDatasets.id_dataset == CorModuleDataset.id_dataset,
join_depth=0,
lazy="joined",
)
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
data = DB.Column(JSONB)
class TTarifs (DB.Model):
__tablename__ = "t_tarifs"
__table_args__ = {'schema': SCHEMA}
id_tarif = DB.Column('id_tarif', DB.Integer, primary_key = True)
id_dispositif = DB.Column('id_dispositif', DB.Integer, DB.ForeignKey('pr_psdrf.t_dispositifs.id_dispositif'))
code_essence = DB.Column('code_essence', DB.String, DB.ForeignKey('pr_psdrf.bib_essences.code_essence'))
type_tarif = DB.Column('type_tarif', DB.String)
num_tarif = DB.Column('num_tarif', DB.Float)
dispositif = DB.relationship('TDispositifs', foreign_keys=id_dispositif)
essence = DB.relationship('BibEssences', foreign_keys=code_essence)
class CorExportsRoles(DB.Model):
__tablename__ = 'cor_exports_roles'
__table_args__ = {'schema': 'gn_exports'}
id_export = DB.Column(DB.Integer(),
DB.ForeignKey(Export.id),
primary_key=True,
nullable=False)
export = DB.relationship('Export', foreign_keys=[id_export], lazy='joined')
id_role = DB.Column(DB.Integer,
DB.ForeignKey(User.id_role),
primary_key=True,
nullable=False)
role = DB.relationship('User', foreign_keys=[id_role], lazy='joined')
class TAcquisitionFrameworkDetails(TAcquisitionFramework):
"""
Class which extends TAcquisitionFramework with nomenclatures relationships
"""
nomenclature_territorial_level = DB.relationship(
TNomenclatures,
foreign_keys=[TAcquisitionFramework.id_nomenclature_territorial_level],
)
nomenclature_financing_type = DB.relationship(
TNomenclatures,
foreign_keys=[TAcquisitionFramework.id_nomenclature_financing_type],
)
class TMonitoringSitesGroups(DB.Model):
__tablename__ = 't_sites_groups'
__table_args__ = {'schema': 'gn_monitoring'}
id_sites_group = DB.Column(DB.Integer,
primary_key=True,
nullable=False,
unique=True)
id_module = DB.Column(DB.ForeignKey('gn_commons.t_modules.id_module'),
nullable=False,
unique=True)
uuid_sites_group = DB.Column(UUID(as_uuid=True), default=uuid4)
sites_group_name = DB.Column(DB.Unicode)
sites_group_code = DB.Column(DB.Unicode)
sites_group_description = DB.Column(DB.Unicode)
comments = DB.Column(DB.Unicode)
data = DB.Column(JSONB)
medias = DB.relationship(
TMedias,
primaryjoin=(TMedias.uuid_attached_row == uuid_sites_group),
foreign_keys=[TMedias.uuid_attached_row],
lazy="joined",
)
sites = DB.relationship(
TMonitoringSites,
uselist=True, # pourquoi pas par defaut ?
primaryjoin=(TMonitoringSites.id_sites_group == id_sites_group),
foreign_keys=[TMonitoringSites.id_sites_group],
lazy="joined",
)
nb_sites = column_property(
select([func.count(TMonitoringSites.id_sites_group)]).\
where(TMonitoringSites.id_sites_group==id_sites_group)
)
nb_visits = column_property(
select([func.count(TMonitoringVisits.id_base_site)]).\
where(and_(
TMonitoringVisits.id_base_site == TMonitoringSites.id_base_site,
TMonitoringSites.id_sites_group == id_sites_group
)
)
)
class TArbres (DB.Model):
__tablename__ = "t_arbres"
__table_args__ = {'schema': SCHEMA}
id_arbre = DB.Column('id_arbre', DB.Integer, primary_key = True)
id_arbre_orig = DB.Column('id_arbre_orig', DB.Integer)
id_placette = DB.Column('id_placette', DB.Integer, DB.ForeignKey('pr_psdrf.t_placettes.id_placette'))
code_essence = DB.Column('code_essence', DB.String, DB.ForeignKey('pr_psdrf.bib_essences.code_essence'))
azimut = DB.Column('azimut', DB.Float)
distance = DB.Column('distance', DB.Float)
taillis = DB.Column('taillis', DB.Boolean)
observation = DB.deferred(DB.Column('observation', DB.Text))
placette = DB.relationship('TPlacettes', foreign_keys=id_placette)
essence = DB.relationship('BibEssences', foreign_keys=code_essence)
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)
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),
)
validations = DB.relationship(
"TValidations",
primaryjoin=(TValidations.uuid_attached_row == unique_id_sinp),
foreign_keys=[unique_id_sinp],
uselist=True,
)
class TPlacettes (DB.Model):
__tablename__ = "t_placettes"
__table_args__ = {'schema': SCHEMA}
id_placette = DB.Column('id_placette', DB.Integer, primary_key = True)
id_dispositif = DB.Column('id_dispositif', DB.Integer, DB.ForeignKey('pr_psdrf.t_dispositifs.id_dispositif'))
id_placette_orig = DB.Column('id_placette_orig', DB.String)
strate = DB.Column('strate', DB.Integer)
pente = DB.Column('pente', DB.Float)
poids_placette = DB.Column('poids_placette', DB.Float)
correction_pente = DB.Column('correction_pente', DB.Boolean)
exposition = DB.Column('exposition', DB.Integer)
profondeur_app = DB.Column('profondeur_app', DB.String)
profondeur_hydr = DB.Column('profondeur_hydr', DB.Float)
texture = DB.Column('texture', DB.String)
habitat = DB.Column('habitat', DB.String)
station = DB.Column('station', DB.String)
typologie = DB.Column('typologie', DB.String)
groupe = DB.Column('groupe', DB.String)
groupe1 = DB.Column('groupe1', DB.String)
groupe2 = DB.Column('groupe2', DB.String)
ref_habitat = DB.Column('ref_habitat', DB.String)
precision_habitat = DB.deferred(DB.Column('precision_habitat', DB.Text))
ref_station = DB.Column('ref_station', DB.String)
ref_typologie = DB.Column('ref_typologie', DB.String)
descriptif_groupe = DB.deferred(DB.Column('descriptif_groupe', DB.Text))
descriptif_groupe1 = DB.deferred(DB.Column('descriptif_groupe1', DB.Text))
descriptif_groupe2 = DB.deferred(DB.Column('descriptif_groupe2', DB.Text))
precision_gps = DB.Column('precision_gps', DB.String)
cheminement = DB.deferred(DB.Column('cheminement', DB.Text))
geom = DB.Column('geom', Geometry('POINT', 2154))
geom_wgs84 = DB.Column('geom_wgs84', Geometry('POINT', 4326))
dispositif = DB.relationship('TDispositifs', foreign_keys=id_dispositif, back_populates='placettes')
class Export(DB.Model):
__tablename__ = 't_exports'
__table_args__ = {'schema': 'gn_exports'}
id = DB.Column(DB.Integer, primary_key=True, nullable=False) # noqa: A003
label = DB.Column(DB.Text, nullable=False, unique=True, index=True)
schema_name = DB.Column(DB.Text, nullable=False)
view_name = DB.Column(DB.Text, nullable=False)
desc = DB.Column(DB.Text)
geometry_field = DB.Column(DB.Text)
geometry_srid = DB.Column(DB.Integer)
public = DB.Column(DB.Boolean, nullable=False, default=False)
id_licence = DB.Column(DB.Integer(),
DB.ForeignKey(Licences.id_licence),
primary_key=True,
nullable=False)
licence = DB.relationship(
'Licences',
primaryjoin='Export.id_licence==Licences.id_licence',
backref='exports')
def __str__(self):
return "{}".format(self.label)
__repr__ = __str__
class Habref(DB.Model):
__tablename__ = 'habref'
__table_args__ = {'schema': 'ref_habitat', 'extend_existing': True}
cd_hab = DB.Column(DB.Integer,
primary_key=True,
server_default=DB.FetchedValue())
fg_validite = DB.Column(DB.String(20), nullable=False)
cd_typo = DB.Column(DB.ForeignKey('ref_habitat.typoref.cd_typo',
ondelete='CASCADE',
onupdate='CASCADE'),
nullable=False)
lb_code = DB.Column(DB.String(50))
lb_hab_fr = DB.Column(DB.String(255))
lb_hab_fr_complet = DB.Column(DB.String(255))
lb_hab_en = DB.Column(DB.String(255))
lb_auteur = DB.Column(DB.String(255))
niveau = DB.Column(DB.Integer)
lb_niveau = DB.Column(DB.String(100))
cd_hab_sup = DB.Column(DB.Integer, nullable=False)
path_cd_hab = DB.Column(DB.String(2000))
france = DB.Column(DB.String(5))
lb_description = DB.Column(DB.String(4000))
typoref = DB.relationship('Typoref',
primaryjoin='Habref.cd_typo == Typoref.cd_typo',
backref='habrefs')
class TModules(DB.Model):
__tablename__ = "t_modules"
__table_args__ = {"schema": "gn_commons"}
type = DB.Column(DB.Unicode)
mapper_args = {
'polymorphic_identity': 'modules',
'polymorphic_on': 'type',
}
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)
module_order = DB.Column(DB.Integer)
meta_create_date = DB.Column(DB.DateTime)
meta_update_date = DB.Column(DB.DateTime)
objects = DB.relationship(
"TObjects",
secondary= lambda:_resolve_import_cor_object_module(),
backref='modules'
)
def __str__(self):
return self.module_label.capitalize()
class TObservations(DB.Model):
__tablename__ = "t_observations"
__table_args__ = {"schema": "gn_monitoring"}
id_observation = DB.Column(DB.Integer,
primary_key=True,
nullable=False,
unique=True)
id_base_visit = DB.Column(
DB.ForeignKey('gn_monitoring.t_base_visits.id_base_visit'))
cd_nom = DB.Column(DB.Integer)
comments = DB.Column(DB.String)
uuid_observation = DB.Column(UUID(as_uuid=True), default=uuid4)
medias = DB.relationship(
TMedias,
lazy='joined',
primaryjoin=(TMedias.uuid_attached_row == uuid_observation),
foreign_keys=[TMedias.uuid_attached_row])
t_observation_details = DB.relation(
TMonitoringObservationDetails,
primaryjoin=(
id_observation == TMonitoringObservationDetails.id_observation),
foreign_keys=[TMonitoringObservationDetails.id_observation],
cascade="all,delete")
class CorCyclesRoles (DB.Model):
__tablename__ = "cor_cycles_roles"
__table_args__ = {'schema': SCHEMA}
id_cycle = DB.Column('id_cycle', DB.Integer, DB.ForeignKey('pr_psdrf.t_cycles.id_cycle'), primary_key = True)
id_role = DB.Column('id_role', DB.Integer, primary_key = True)
cycle = DB.relationship('TCycles', foreign_keys=id_cycle)
class TAcquisitionFrameworkDetails(TAcquisitionFramework):
"""
Class which extends TAcquisitionFramework with nomenclatures relationships
"""
datasets = DB.relationship(TDatasetDetails, lazy="joined")
nomenclature_territorial_level = DB.relationship(
TNomenclatures,
primaryjoin=(TNomenclatures.id_nomenclature ==
TAcquisitionFramework.id_nomenclature_territorial_level),
)
nomenclature_financing_type = DB.relationship(
TNomenclatures,
primaryjoin=(TNomenclatures.id_nomenclature ==
TAcquisitionFramework.id_nomenclature_financing_type),
)
class VReleveList(ReleveModel):
__tablename__ = "v_releve_list"
__table_args__ = {"schema": "pr_occtax"}
id_releve_occtax = DB.Column(DB.Integer, primary_key=True)
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)
meta_device_entry = DB.Column(DB.Unicode)
comment = DB.Column(DB.Unicode)
geom_4326 = DB.Column(Geometry("GEOMETRY", 4326))
taxons = DB.Column(DB.Unicode)
leaflet_popup = DB.Column(DB.Unicode)
observateurs = DB.Column(DB.Unicode)
dataset_name = DB.Column(DB.Unicode)
observers_txt = DB.Column(DB.Unicode)
nb_occ = DB.Column(DB.Integer)
nb_observer = DB.Column(DB.Integer)
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_releve_occtax", recursif)
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)
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 VReleveList(ReleveModel):
__tablename__ = 'v_releve_list'
__table_args__ = {'schema': 'pr_occtax'}
id_releve_occtax = DB.Column(DB.Integer, primary_key=True)
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)
meta_device_entry = DB.Column(DB.Unicode)
comment = DB.Column(DB.Unicode)
geom_4326 = DB.Column(Geometry('GEOMETRY', 4326))
taxons = DB.Column(DB.Unicode)
leaflet_popup = DB.Column(DB.Unicode)
observateurs = DB.Column(DB.Unicode)
dataset_name = DB.Column(DB.Unicode)
observers = DB.relationship(
'TRoles',
secondary=corRoleRelevesOccurrence,
primaryjoin=(
corRoleRelevesOccurrence.c.id_releve_occtax == id_releve_occtax),
secondaryjoin=(corRoleRelevesOccurrence.c.id_role == TRoles.id_role),
foreign_keys=[
corRoleRelevesOccurrence.c.id_releve_occtax,
corRoleRelevesOccurrence.c.id_role
])
def get_geofeature(self, recursif=True):
return self.as_geofeature('geom_4326', 'id_releve_occtax', recursif)
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'))
visit_date_min = DB.Column(DB.DateTime)
visit_date_max = DB.Column(DB.DateTime)
# geom = DB.Column(Geometry('GEOMETRY', 4326))
comments = DB.Column(DB.DateTime)
uuid_base_visit = DB.Column(UUID(as_uuid=True),
default=select([func.uuid_generate_v4()]))
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
])
class TMonitoringVisits(TBaseVisits):
__tablename__ = "t_visit_complements"
__table_args__ = {"schema": "gn_monitoring"}
__mapper_args__ = {
'polymorphic_identity': 'monitoring_visit',
}
id_base_visit = DB.Column(
DB.ForeignKey('gn_monitoring.t_base_visits.id_base_visit'),
nullable=False,
primary_key=True)
data = DB.Column(JSONB)
medias = DB.relationship(
TMedias,
primaryjoin=(TMedias.uuid_attached_row == TBaseVisits.uuid_base_visit),
foreign_keys=[TMedias.uuid_attached_row])
observations = DB.relation(
"TMonitoringObservations",
primaryjoin=(TObservations.id_base_visit == TBaseVisits.id_base_visit),
foreign_keys=[TObservations.id_base_visit],
cascade="all,delete")
@hybrid_property
def nb_observations(self):
return len(self.observations)
class TMonitoringSites(TBaseSites):
__tablename__ = 't_site_complements'
__table_args__ = {'schema': 'gn_monitoring'}
__mapper_args__ = {
'polymorphic_identity': 'monitoring_site',
}
id_base_site = DB.Column(
DB.ForeignKey('gn_monitoring.t_base_sites.id_base_site'),
nullable=False,
primary_key=True)
id_module = DB.Column(DB.ForeignKey('gn_commons.t_modules.id_module'),
nullable=False,
primary_key=True)
data = DB.Column(JSONB)
# unmap modules
TBaseSites.modules = 0
visits = DB.relationship(
TMonitoringVisits,
primaryjoin=(TBaseSites.id_base_site == TBaseVisits.id_base_site),
foreign_keys=[TBaseVisits.id_base_site],
cascade="all,delete")
medias = DB.relationship(
TMedias,
primaryjoin=(TMedias.uuid_attached_row == TBaseSites.uuid_base_site),
foreign_keys=[TMedias.uuid_attached_row],
cascade="all,delete")
@hybrid_property
def last_visit(self):
last_visit = None
if self.visits:
for visit in self.visits:
if not last_visit or last_visit < visit.visit_date_min:
last_visit = visit.visit_date_min
return last_visit
@hybrid_property
def nb_visits(self):
return len(self.visits)
