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 CorListHabitat(DB.Model):
__tablename__ = 'cor_list_habitat'
__table_args__ = {'schema': 'ref_habitat', 'extend_existing': True}
id_cor_list = DB.Column(DB.Integer,
primary_key=True,
server_default=DB.FetchedValue())
id_list = DB.Column(DB.ForeignKey('ref_habitat.habref.bib_list_habitat',
onupdate='CASCADE'),
nullable=False)
cd_hab = DB.Column(DB.ForeignKey('ref_habitat.habref.cd_hab',
onupdate='CASCADE'),
nullable=False)
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 CorNomListe(DB.Model):
__tablename__ = "cor_nom_liste"
__table_args__ = {"schema": "taxonomie"}
id_liste = DB.Column(
DB.Integer,
DB.ForeignKey("taxonomie.bib_listes.id_liste"),
nullable=False,
primary_key=True,
)
id_nom = DB.Column(
DB.Integer,
DB.ForeignKey("taxonomie.bib_noms.id_nom"),
nullable=False,
primary_key=True,
)
class CorRelevePlotStrat(DB.Model):
__tablename__ = 'cor_releve_plot_strats'
__table_args__ = {'schema': 'pr_monitoring_habitat_station'}
id_releve_plot_strat = DB.Column(DB.Integer,
primary_key=True,
server_default=DB.FetchedValue())
id_releve_plot = DB.Column(DB.ForeignKey(
'pr_monitoring_habitat_station.t_releve_plots.id_releve_plot',
onupdate='CASCADE'),
nullable=False)
id_nomenclature_strate = DB.Column(DB.ForeignKey(
'ref_nomenclatures.t_nomenclatures.id_nomenclature',
onupdate='CASCADE'),
nullable=False)
cover_pourcentage = DB.Column(DB.Integer)
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 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 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 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 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 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 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 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 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)
class TAdditionalFields(DB.Model):
__tablename__ = "t_additional_fields"
__table_args__ = {"schema": "gn_commons"}
id_field = DB.Column(DB.Integer, primary_key=True)
field_name = DB.Column(DB.String, nullable=False)
field_label = DB.Column(DB.String, nullable=False)
required = DB.Column(DB.Boolean)
description = DB.Column(DB.String)
quantitative = DB.Column(DB.Boolean, default=False)
unity = DB.Column(DB.String(50))
field_values = DB.Column(JSONB)
code_nomenclature_type = DB.Column(DB.String,
DB.ForeignKey("ref_nomenclatures.bib_nomenclatures_types.mnemonique"),
)
additional_attributes = DB.Column(JSONB)
id_widget = DB.Column(DB.Integer,
DB.ForeignKey("gn_commons.bib_widgets.id_widget"),
nullable=False
)
id_list = DB.Column(DB.Integer)
exportable = DB.Column(DB.Boolean, default=True)
field_order = DB.Column(DB.Integer)
type_widget = DB.relationship("BibWidgets")
bib_nomenclature_type = DB.relationship(
"BibNomenclaturesTypes",
primaryjoin="BibNomenclaturesTypes.mnemonique == TAdditionalFields.code_nomenclature_type"
)
additional_attributes = DB.Column(JSONB)
multiselect = DB.Column(DB.Boolean)
key_label = DB.Column(DB.String)
key_value = DB.Column(DB.String)
api = DB.Column(DB.String)
modules = DB.relationship(
"TModules",
secondary=cor_field_module,
)
objects = DB.relationship(
"TObjects",
secondary=cor_field_object
)
datasets = DB.relationship(
"TDatasets",
secondary=cor_field_dataset
)
def __str__(self):
return f"{self.field_label} ({self.description})"
class TInfosSite(DB.Model):
__tablename__ = 't_infos_site'
__table_args__ = {'schema': 'pr_monitoring_habitat_territory'}
id_infos_site = DB.Column(DB.Integer, primary_key=True)
id_base_site = DB.Column(
DB.ForeignKey('gn_monitoring.t_base_sites.id_base_site'),
nullable=False)
cd_hab = DB.Column(DB.ForeignKey('ref_habitat.habref.cd_hab'),
nullable=False)
# habref = DB.relationship('Habref', primaryjoin='TInfosSite.cd_hab == Habref.cd_hab', backref='t_infos_sites')
#t_base_site = DB.relationship('TBaseSites', primaryjoin='TInfosSite.id_base_site == TBaseSites.id_base_site', backref='t_infos_sites')
t_base_site = DB.relationship('TBaseSites')
geom = association_proxy('t_base_site', 'geom')
def get_geofeature(self, recursif=True):
return self.as_geofeature('geom', 'id_infos_site', recursif)
class TBmSup30 (DB.Model):
__tablename__ = "t_bm_sup_30"
__table_args__ = {'schema': SCHEMA}
id_bm_sup_30 = DB.Column('id_bm_sup_30', DB.Integer, primary_key = True)
id_bm_sup_30_orig = DB.Column('id_bm_sup_30_orig', DB.Integer)
id_placette = DB.Column('id_placette', DB.Integer, DB.ForeignKey('pr_psdrf.t_placettes.id_placette'))
id_arbre = DB.Column('id_arbre', DB.Integer, DB.ForeignKey('pr_psdrf.t_arbres.id_arbre'))
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)
orientation = DB.Column('orientation', DB.Float)
azimut_souche = DB.Column('azimut_souche', DB.Float)
distance_souche = DB.Column('distance_souche', DB.Float)
observation = DB.deferred(DB.Column('observation', DB.Text))
placette = DB.relationship('TPlacettes', foreign_keys=id_placette)
essence = DB.relationship('BibEssences', foreign_keys=code_essence)
arbre = DB.relationship('TArbres', foreign_keys=id_arbre)
class ExportLog(DB.Model):
__tablename__ = 't_exports_logs'
__table_args__ = {'schema': 'gn_exports'}
id = DB.Column(DB.Integer, primary_key=True, nullable=False) # noqa: A003
id_role = DB.Column(DB.Integer, DB.ForeignKey(User.id_role))
role = DB.relationship('User', foreign_keys=[id_role], lazy='joined')
id_export = DB.Column(DB.Integer(), DB.ForeignKey(Export.id))
export = DB.relationship('Export', lazy='joined')
format = DB.Column(DB.String(4), nullable=False) # noqa: A003
start_time = DB.Column(DB.DateTime, nullable=False)
end_time = DB.Column(DB.DateTime)
status = DB.Column(DB.Integer, default=-2)
log = DB.Column(DB.Text)
def __init__(self, id_role, id_export, export_format, start_time, end_time,
status, log):
self.id_role = id_role
self.id_export = id_export
self.format = export_format
self.start_time = start_time
self.end_time = end_time
self.status = status
self.log = log
@classmethod
def from_dict(cls, adict):
export_log = ExportLog(id_role=adict['id_role'],
id_export=adict['id_export'],
export_format=adict['export_format'],
start_time=adict['start_time'],
end_time=adict['end_time'],
status=adict['status'],
log=adict['log'])
return export_log
@classmethod
def record(cls, adict):
try:
x = ExportLog.from_dict(adict)
DB.session.add(x)
DB.session.commit()
except Exception as e:
DB.session.rollback()
raise e('Echec de journalisation.')
class TBmSup30Mesures (DB.Model):
__tablename__ = "t_bm_sup_30_mesures"
__table_args__ = {'schema': SCHEMA}
id_bm_sup_30_mesure = DB.Column('id_bm_sup_30_mesure', DB.Integer, primary_key = True)
id_bm_sup_30 = DB.Column('id_bm_sup_30', DB.Integer, DB.ForeignKey('pr_psdrf.t_bm_sup_30.id_bm_sup_30'))
id_cycle = DB.Column('id_cycle', DB.Integer, DB.ForeignKey('pr_psdrf.t_cycles.id_cycle'))
diametre_ini = DB.Column('diametre_ini', DB.Float)
diametre_med = DB.Column('diametre_med', DB.Float)
diametre_fin = DB.Column('diametre_fin', DB.Float)
diametre_130 = DB.Column('diametre_130', DB.Float)
longueur = DB.Column('longueur', DB.Float)
ratio_hauteur = DB.Column('ratio_hauteur', DB.Boolean)
contact = DB.Column('contact', DB.Float)
chablis = DB.Column('chablis', DB.Boolean)
stade_durete = DB.Column('stade_durete', DB.Integer)
stade_ecorce = DB.Column('stade_ecorce', DB.Integer)
observation = DB.deferred(DB.Column('observation', DB.Text))
bm_sup_30 = DB.relationship('TBmSup30', foreign_keys=id_bm_sup_30)
cycle = DB.relationship('TCycles', foreign_keys=id_cycle)
class TCategories (DB.Model):
__tablename__ = "t_categories"
__table_args__ = {'schema': SCHEMA}
id_category = DB.Column('id_category', DB.Integer, primary_key = True)
id_dispositif = DB.Column('id_dispositif', DB.Integer, DB.ForeignKey('pr_psdrf.t_dispositifs.id_dispositif'))
pb = DB.Column('pb', DB.Float)
bm = DB.Column('bm', DB.Float)
gb = DB.Column('gb', DB.Float)
tgb = DB.Column('tgb', DB.Float)
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 CorCyclesPlacettes (DB.Model):
__tablename__ = "cor_cycles_placettes"
__table_args__ = {'schema': SCHEMA}
id_cycle_placette = DB.Column('id_cycle_placette', DB.Integer, primary_key = True)
id_cycle = DB.Column('id_cycle', DB.Integer, DB.ForeignKey('pr_psdrf.t_cycles.id_cycle'))
id_placette = DB.Column('id_placette', DB.Integer, DB.ForeignKey('pr_psdrf.t_placettes.id_placette'))
date_releve = DB.Column('date_releve', DB.Date)
date_intervention = DB.Column('date_intervention', DB.String)
nature_intervention = DB.Column('nature_intervention', DB.String)
gestion_placette = DB.Column('gestion_placette', DB.String)
id_nomenclature_castor = DB.Column('id_nomenclature_castor', DB.Integer)
id_nomenclature_frottis = DB.Column('id_nomenclature_frottis', DB.Integer)
id_nomenclature_boutis = DB.Column('id_nomenclature_boutis', DB.Integer)
recouv_herbes_basses = DB.Column('recouv_herbes_basses', DB.Float)
recouv_herbes_hautes = DB.Column('recouv_herbes_hautes', DB.Float)
recouv_buissons = DB.Column('recouv_buissons', DB.Float)
recouv_arbres = DB.Column('recouv_arbres', DB.Float)
cycle = DB.relationship('TCycles', foreign_keys=id_cycle)
placette = DB.relationship('TPlacettes', foreign_keys=id_placette)
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 TReperes (DB.Model):
__tablename__ = "t_reperes"
__table_args__ = {'schema': SCHEMA}
id_repere = DB.Column('id_repere', DB.Integer, primary_key = True)
id_placette = DB.Column('id_placette', DB.Integer, DB.ForeignKey('pr_psdrf.t_placettes.id_placette'))
azimut = DB.Column('azimut', DB.Float)
distance = DB.Column('distance', DB.Float)
diametre = DB.Column('diametre', DB.Float)
observation = DB.deferred(DB.Column('observation', DB.Text))
placette = DB.relationship('TPlacettes', foreign_keys=id_placette)
class CorVisitPerturbation(DB.Model):
__tablename__ = 'cor_visit_perturbation'
__table_args__ = {'schema': 'pr_monitoring_habitat_territory'}
id_base_visit = DB.Column(DB.ForeignKey(
'gn_monitoring.t_base_visits.id_base_visit', onupdate='CASCADE'),
primary_key=True,
nullable=False)
id_nomenclature_perturbation = DB.Column(DB.ForeignKey(
'ref_nomenclatures.t_nomenclatures.id_nomenclature',
onupdate='CASCADE'),
primary_key=True,
nullable=False)
create_date = DB.Column(DB.DateTime, nullable=False, default=func.now())
#t_base_visit = DB.relationship('TVisitSHT', primaryjoin='CorVisitPerturbation.id_base_visit == TVisitSHT.id_base_visit', backref='cor_visit_perturbations')
t_nomenclature = DB.relationship(
'TNomenclature',
primaryjoin=
'CorVisitPerturbation.id_nomenclature_perturbation == TNomenclature.id_nomenclature',
backref='cor_visit_perturbations')
class TMonitoringObservationDetails(DB.Model):
__tablename__ = "t_observation_details"
__table_args__ = {"schema": "gn_monitoring"}
id_observation_detail = DB.Column(DB.Integer,
primary_key=True,
nullable=False,
unique=True)
id_observation = DB.Column(
DB.ForeignKey('gn_monitoring.t_observations.id_observation'))
data = DB.Column(JSONB)
class TTransect(DB.Model):
__tablename__ = 't_transects'
__table_args__ = {'schema': 'pr_monitoring_habitat_station'}
id_transect = DB.Column(DB.Integer,
primary_key=True,
server_default=DB.FetchedValue())
id_base_site = DB.Column(DB.ForeignKey(
'gn_monitoring.t_base_sites.id_base_site',
ondelete='CASCADE',
onupdate='CASCADE'),
nullable=False)
transect_label = DB.Column(DB.String(50))
geom_start = DB.Column(Geometry('POINT', 4326))
geom_end = DB.Column(Geometry('POINT', 4326))
id_nomenclature_plot_position = DB.Column(DB.Integer, nullable=False)
cd_hab = DB.Column(DB.ForeignKey('ref_habitat.habref.cd_hab',
onupdate='CASCADE'),
nullable=False)
plot_size = DB.Column(DB.String(50))
# habref = DB.relationship('HabrefSHS', primaryjoin='TTransect.cd_hab == HabrefSHS.cd_hab', backref='t_transects')
t_base_site = DB.relationship('TBaseSites')
cor_plots = DB.relationship("TPlot", backref='t_plots')
def get_geofeature(self, recursif=False):
line = self.points_to_linestring()
feature = Feature(
id=str(self.id_base_site),
geometry=line,
properties=self.as_dict(recursif),
)
return feature
def points_to_linestring(self):
point1 = (DB.session.scalar(geo_funcs.ST_X(self.geom_start)),
DB.session.scalar(geo_funcs.ST_Y(self.geom_start)))
point2 = (DB.session.scalar(geo_funcs.ST_X(self.geom_end)),
DB.session.scalar(geo_funcs.ST_Y(self.geom_end)))
return LineString([point1, point2])
class CorVisitTaxon(DB.Model):
__tablename__ = 'cor_visit_taxons'
__table_args__ = {'schema': 'pr_monitoring_habitat_territory'}
id_cor_visite_taxons = DB.Column(DB.Integer,
nullable=False,
server_default=DB.FetchedValue(),
primary_key=True)
id_base_visit = DB.Column(
DB.ForeignKey('gn_monitoring.t_base_visits.id_base_visit',
ondelete='CASCADE',
onupdate='CASCADE'))
cd_nom = DB.Column(DB.Integer)
class TCycles (DB.Model):
__tablename__ = "t_cycles"
__table_args__ = {'schema': SCHEMA}
id_cycle = DB.Column('id_cycle', DB.Integer, primary_key = True)
id_dispositif = DB.Column('id_dispositif', DB.Integer, DB.ForeignKey('pr_psdrf.t_dispositifs.id_dispositif'))
num_cycle = DB.Column('num_cycle', DB.Integer)
coeff = DB.Column('coeff', DB.Integer)
date_debut = DB.Column('date_debut', DB.Date)
date_fin = DB.Column('date_fin', DB.Date)
diam_lim = DB.Column('diam_lim', DB.Float)
monitor = DB.Column('monitor', DB.String)
dispositif = DB.relationship('TDispositifs', foreign_keys=id_dispositif)
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
)
)
)
