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"),