class VmValidProfiles(DB.Model): __tablename__ = "vm_valid_profiles" __table_args__ = {"schema": "gn_profiles"} cd_ref = DB.Column(DB.Integer, primary_key=True) valid_distribution = DB.Column(Geometry("GEOMETRY", config["LOCAL_SRID"])) altitude_min = DB.Column(DB.Integer) altitude_max = DB.Column(DB.Integer) first_valid_data = DB.Column(DB.DateTime) last_valid_data = DB.Column(DB.DateTime) count_valid_data = DB.Column(DB.Integer) active_life_stage = DB.Column(DB.Boolean) def get_geofeature(self, recursif=False, columns=()): return self.as_geofeature("valid_distribution", "cd_ref", recursif, columns=columns)
class TParameters(DB.Model): __tablename__ = 't_parameters' __table_args__ = {'schema': 'gn_commons'} id_parameter = DB.Column(DB.Integer, primary_key=True) id_organism = DB.Column( DB.Integer, ForeignKey('utilisateurs.bib_organismes.id_organisme')) parameter_name = DB.Column(DB.Unicode) parameter_desc = DB.Column(DB.Unicode) parameter_value = DB.Column(DB.Unicode) parameter_extra_value = DB.Column(DB.Unicode)
class THistoryActions(DB.Model): __tablename__ = "t_history_actions" __table_args__ = {"schema": "gn_commons"} id_history_action = DB.Column(DB.Integer, primary_key=True) id_table_location = DB.Column(DB.Integer) uuid_attached_row = DB.Column(UUID(as_uuid=True)) operation_type = DB.Column(DB.Unicode) operation_date = DB.Column(DB.DateTime) table_content = DB.Column(DB.Unicode)
class TMappings(DB.Model): __tablename__ = "t_mappings" __table_args__ = {"schema": "gn_imports", "extend_existing": True} id_mapping = DB.Column(DB.Integer, primary_key=True, autoincrement=True) mapping_label = DB.Column(DB.Unicode, nullable=False) mapping_type = DB.Column(DB.Unicode, nullable=False) active = DB.Column(DB.Boolean, nullable=False) temporary = DB.Column(DB.Boolean, nullable=False, default=False) is_public = DB.Column(DB.Boolean, default=False)
class BibThemes(DB.Model): __tablename__ = "dict_themes" __table_args__ = {"schema": "gn_imports", "extend_existing": True} id_theme = DB.Column(DB.Integer, primary_key=True) name_theme = DB.Column(DB.Unicode, nullable=False) fr_label = DB.Column(DB.Unicode, nullable=False) eng_label = DB.Column(DB.Unicode, nullable=True) desc_theme = DB.Column(DB.Unicode, nullable=True) order_theme = DB.Column(DB.Integer, nullable=False)
class TMappingsFields(DB.Model): __tablename__ = "t_mappings_fields" __table_args__ = {"schema": "gn_imports", "extend_existing": True} id_match_fields = DB.Column(DB.Integer, primary_key=True, autoincrement=True) id_mapping = DB.Column(DB.Integer, primary_key=True) source_field = DB.Column(DB.Unicode, nullable=False) target_field = DB.Column(DB.Unicode, nullable=False) is_selected = DB.Column(DB.Boolean, nullable=False) is_added = DB.Column(DB.Boolean, nullable=False)
class TParameters(DB.Model): __tablename__ = "t_parameters" __table_args__ = {"schema": "gn_commons"} id_parameter = DB.Column(DB.Integer, primary_key=True) id_organism = DB.Column( DB.Integer, ForeignKey("utilisateurs.bib_organismes.id_organisme")) parameter_name = DB.Column(DB.Unicode) parameter_desc = DB.Column(DB.Unicode) parameter_value = DB.Column(DB.Unicode) parameter_extra_value = DB.Column(DB.Unicode)
class TValidations(DB.Model): __tablename__ = "t_validations" __table_args__ = {"schema": "gn_commons"} id_validation = DB.Column(DB.Integer, primary_key=True) id_table_location = DB.Column(DB.Integer) uuid_attached_row = DB.Column(UUID(as_uuid=True)) id_nomenclature_valid_status = DB.Column(DB.Integer) id_validator = DB.Column(DB.Integer) validation_auto = DB.Column(DB.Boolean) validation_comment = DB.Column(DB.Unicode) validation_date = DB.Column(DB.DateTime) validation_auto = DB.Column(DB.Boolean) validation_label = DB.relationship( TNomenclatures, primaryjoin=(TNomenclatures.id_nomenclature == id_nomenclature_valid_status), foreign_keys=[id_nomenclature_valid_status], ) validator_role = DB.relationship( User, primaryjoin=(User.id_role == id_validator), foreign_keys=[id_validator] ) def __init__( self, id_validation, id_table_location, uuid_attached_row, id_nomenclature_valid_status, id_validator, validation_comment, validation_date, validation_auto, ): self.id_table_location = id_table_location self.uuid_attached_row = uuid_attached_row self.id_nomenclature_valid_status = id_nomenclature_valid_status self.id_validator = id_validator self.validation_comment = validation_comment self.validation_date = validation_date self.validation_auto = validation_auto
class TVisiteObservation(DB.Model): __tablename__ = 't_visite_observations' __table_args__ = {'schema': 'monitoring_oedic'} id_visite_observation = DB.Column(DB.Integer, primary_key=True) id_base_visit = DB.Column(DB.Integer, ForeignKey(TVisiteInformation.id_base_visit)) time_observation = DB.Column(DB.DateTime) nb_oiseaux = DB.Column(DB.Integer) remarque_observation = DB.Column(DB.Text) id_nomenclature_nature_observation = DB.Column(DB.Integer)
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 TValidations(DB.Model): __tablename__ = "t_validations" __table_args__ = {"schema": "gn_commons", "extend_existing": True} id_validation = DB.Column(DB.Integer, primary_key=True) id_table_location = DB.Column(DB.Integer) uuid_attached_row = DB.Column(UUID(as_uuid=True)) id_nomenclature_valid_status = DB.Column(DB.Integer) id_validator = DB.Column(DB.Integer) validation_auto = DB.Column(DB.Boolean) validation_comment = DB.Column(DB.Unicode) validation_date = DB.Column(DB.DateTime) validation_auto = DB.Column(DB.Boolean) validation_label = DB.relationship( TNomenclatures, primaryjoin=( TNomenclatures.id_nomenclature == id_nomenclature_valid_status), foreign_keys=[id_nomenclature_valid_status]) validator_role = DB.relationship( User, primaryjoin=(User.id_role == id_validator), foreign_keys=[id_validator])
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 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 BibListes(DB.Model): __tablename__ = "bib_listes" __table_args__ = {"schema": "taxonomie"} id_liste = DB.Column(DB.Integer, primary_key=True) nom_liste = DB.Column(DB.Unicode) desc_liste = DB.Column(DB.Text) picto = DB.Column(DB.Unicode) regne = DB.Column(DB.Unicode) group2_inpn = DB.Column(DB.Unicode) def __repr__(self): return "<BibListes %r>" % self.nom_liste
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__ @classmethod def from_dict(cls, adict): export = Export(label=adict['label'], schema_name=adict['schema_name'], view_name=adict['view_name'], desc=adict['desc'], geometry_field=adict['geometry_field'], geometry_srid=adict['geometry_srid'], public=adict['public']) return export
class Export(DB.Model): __tablename__ = 't_exports_logs' __table_args__ = {'schema': 'gn_intero', 'extend_existing': True} id = DB.Column(DB.TIMESTAMP(timezone=False), primary_key=True, nullable=False) standard = DB.Column(DB.Numeric, default=0) format = DB.Column(DB.Integer, nullable=False) status = DB.Column(DB.Numeric, default=-2) log = DB.Column(DB.UnicodeText) start = DB.Column(DB.DateTime) end = DB.Column(DB.DateTime) id_export = DB.Column(DB.Integer(), DB.ForeignKey('gn_intero.t_exports.id')) export = DB.relationship('ExportType', foreign_keys='Export.id_export', backref=DB.backref('ExportType', lazy='dynamic')) def __init__(self, standard, format, selection=None): self.standard = standard self.id = datetime.utcnow() self.format = int(format) if selection: self.selection = selection def __repr__(self): return "<Export(id='{}', selection='{}', date='{}', standard='{}', format='{}')>".format( # noqa E501 float(self.id), self.export.selection, self.start, self.standard, self.format) # noqa E501 def as_dict(self): return { 'id': float(self.ts()), 'extension': format_map_ext[self.format], 'selection': self.export.selection, 'label': self.export.label, 'standard': standard_map_label[self.standard], 'date': self.start, } def ts(self): return (datetime.strptime(str(self.id), '%Y-%m-%d %H:%M:%S.%f') - datetime.utcfromtimestamp(0)).total_seconds()
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 TValidations(DB.Model): __tablename__ = "t_validations" __table_args__ = {"schema": "gn_commons"} id_validation = DB.Column(DB.Integer, primary_key=True) uuid_attached_row = DB.Column(UUID(as_uuid=True), ForeignKey("gn_synthese.synthese.unique_id_sinp")) id_nomenclature_valid_status = DB.Column( DB.Integer, ForeignKey(TNomenclatures.id_nomenclature), ) nomenclature_valid_status = relationship( TNomenclatures, foreign_keys=[id_nomenclature_valid_status], lazy='joined', ) id_validator = DB.Column(DB.Integer, ForeignKey(User.id_role)) validator_role = DB.relationship(User) validation_auto = DB.Column(DB.Boolean) validation_comment = DB.Column(DB.Unicode) validation_date = DB.Column(DB.TIMESTAMP) validation_auto = DB.Column(DB.Boolean) validation_label = DB.relationship(TNomenclatures)
class TValidations(DB.Model): __tablename__ = 't_validations' __table_args__ = {'schema': 'gn_commons', "extend_existing": True} id_validation = DB.Column(DB.Integer, primary_key=True) id_table_location = DB.Column(DB.Integer) uuid_attached_row = DB.Column(UUID(as_uuid=True)) id_nomenclature_valid_status = DB.Column(DB.Integer) id_validator = DB.Column(DB.Integer) validation_comment = DB.Column(DB.Unicode) validation_date = DB.Column(DB.DateTime) validation_auto = DB.Column(DB.Boolean) def __init__(self, id_validation, id_table_location, uuid_attached_row, id_nomenclature_valid_status, id_validator, validation_comment, validation_date, validation_auto): self.id_table_location = id_table_location self.uuid_attached_row = uuid_attached_row self.id_nomenclature_valid_status = id_nomenclature_valid_status self.id_validator = id_validator self.validation_comment = validation_comment self.validation_date = validation_date self.validation_auto = validation_auto
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(10), 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) @classmethod def record(cls, adict): try: exportLog = cls() exportLog.from_dict(adict) DB.session.add(exportLog) DB.session.commit() except Exception as e: DB.session.rollback()
class HabrefSHS(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', onupdate='CASCADE'), nullable=False) lb_code = DB.Column(DB.String(50)) lb_hab_fr = DB.Column(DB.String(500)) lb_hab_fr_complet = DB.Column(DB.String(500)) lb_hab_en = DB.Column(DB.String(500)) typoref = DB.relationship( 'TyporefSHS', primaryjoin='HabrefSHS.cd_typo == TyporefSHS.cd_typo', backref='habrefs')
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("TRoles", foreign_keys=[id_digitiser]) observers = DB.relationship( 'TRoles', secondary=corVisitObserver, primaryjoin=( corVisitObserver.c.id_base_visit == id_base_visit ), secondaryjoin=(corVisitObserver.c.id_role == TRoles.id_role), foreign_keys=[ corVisitObserver.c.id_base_visit, corVisitObserver.c.id_role ] )
class TRoles (DB.Model): __tablename__ = 't_roles' __table_args__ = {'schema': 'utilisateurs'} id_role = DB.Column(DB.Integer, primary_key=True) identifiant = DB.Column(DB.Unicode) nom_role = DB.Column(DB.Unicode) prenom_role = DB.Column(DB.Unicode) id_organisme = DB.Column(DB.Integer) groupe = DB.Column(DB.Boolean, default=False) def as_dict(self, recursif=False, columns=()): nom_role = self.nom_role or '' prenom_role = self.prenom_role or '' return { 'id_role': self.id_role, 'identifiant': self.identifiant, 'nom_role': self.nom_role, 'prenom_role': self.prenom_role, 'id_organisme': self.id_organisme, 'groupe': self.groupe, 'nom_complet': nom_role+' '+prenom_role }
class VFrameworks(DB.Model): __tablename__ = "vm_synthese_frameworks" __table_args__ = {"schema": "gn_dashboard"} acquisition_framework_name = DB.Column(DB.Unicode, primary_key=True) year = DB.Column(DB.Integer) nb_obs = DB.Column(DB.Integer)
class VSynthese(DB.Model): __tablename__ = "vm_synthese" __table_args__ = {"schema": "gn_dashboard"} id_synthese = DB.Column(DB.Unicode, primary_key=True) id_source = DB.Column(DB.Unicode) id_dataset = DB.Column(DB.Unicode) id_nomenclature_obj_count = DB.Column(DB.Unicode) count_min = DB.Column(DB.Integer) count_max = DB.Column(DB.Integer) cd_nom = DB.Column(DB.Unicode) cd_ref = DB.Column(DB.Unicode) nom_cite = DB.Column(DB.Unicode) id_statut = DB.Column(DB.Unicode) id_rang = DB.Column(DB.Unicode) regne = DB.Column(DB.Unicode) phylum = DB.Column(DB.Unicode) classe = DB.Column(DB.Unicode) ordre = DB.Column(DB.Unicode) famille = DB.Column(DB.Unicode) lb_nom = DB.Column(DB.Unicode) nom_vern = DB.Column(DB.Unicode) group1_inpn = DB.Column(DB.Unicode) group2_inpn = DB.Column(DB.Unicode) altitude_min = DB.Column(DB.Integer) altitude_max = DB.Column(DB.Integer) lon = DB.Column(DB.Unicode) lat = DB.Column(DB.Unicode) date_min = DB.Column(DB.DateTime) date_max = DB.Column(DB.DateTime)
class VTaxonomie(DB.Model): __tablename__ = "vm_taxonomie" __table_args__ = {"schema": "gn_dashboard"} level = DB.Column(DB.Unicode) name_taxon = DB.Column(DB.Unicode, 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, 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 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.Integer) 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, 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() return a_f
class TAcquisitionFramework(CruvedHelper): __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, 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("utilisateurs.t_roles.id_role")) 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) initial_closing_date = DB.Column(DB.DateTime) creator = DB.relationship("User", lazy="select") 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 @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]))
class TDatasets(CruvedHelper): __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, 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) id_digitizer = DB.Column(DB.Integer, ForeignKey("utilisateurs.t_roles.id_role")) creator = DB.relationship("User", lazy="select") modules = DB.relationship("TModules", secondary=cor_module_dataset, lazy="select") # HACK: the relationship is not well defined for many to many relationship # because CorDatasetActor could be an User or an Organisme object... 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, only_query=False, only_user=False): """get the dataset(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 organism) return: a list of id_dataset or a query""" q = DB.session.query(TDatasets).outerjoin( CorDatasetActor, CorDatasetActor.id_dataset == TDatasets.id_dataset) if user.id_organisme is None or only_user: q = q.filter( or_( CorDatasetActor.id_role == user.id_role, TDatasets.id_digitizer == user.id_role, )) else: q = q.filter( or_( CorDatasetActor.id_organism == user.id_organisme, CorDatasetActor.id_role == user.id_role, TDatasets.id_digitizer == user.id_role, )) if only_query: return q return list(set([d.id_dataset for d in q.all()]))