class CorAcquisitionFrameworkActor(DB.Model): __tablename__ = "cor_acquisition_framework_actor" __table_args__ = {"schema": "gn_meta"} id_cafa = DB.Column(DB.Integer, primary_key=True) id_acquisition_framework = DB.Column( DB.Integer, ForeignKey( "gn_meta.t_acquisition_frameworks.id_acquisition_framework"), ) id_role = DB.Column(DB.Integer, ForeignKey("utilisateurs.t_roles.id_role")) id_organism = DB.Column( DB.Integer, ForeignKey("utilisateurs.bib_organismes.id_organisme")) id_nomenclature_actor_role = DB.Column( DB.Integer, ForeignKey("ref_nomenclatures.t_nomenclatures.id_nomenclature"), default=lambda: TNomenclatures.get_default_nomenclature("ROLE_ACTEUR"), ) nomenclature_actor_role = DB.relationship( TNomenclatures, primaryjoin=( TNomenclatures.id_nomenclature == id_nomenclature_actor_role), ) role = DB.relationship(User, primaryjoin=(User.id_role == id_role), foreign_keys=[id_role]) organism = relationship("BibOrganismes", foreign_keys=[id_organism]) @staticmethod def get_actor( id_acquisition_framework, id_nomenclature_actor_role, id_role=None, id_organism=None, ): """ Get CorAcquisitionFrameworkActor from id_dataset, id_actor, and id_role or id_organism. if no object return None """ try: if id_role is None: return ( DB.session.query(CorAcquisitionFrameworkActor).filter_by( id_acquisition_framework=id_acquisition_framework, id_organism=id_organism, id_nomenclature_actor_role=id_nomenclature_actor_role, ).one()) elif id_organism is None: return ( DB.session.query(CorAcquisitionFrameworkActor).filter_by( id_acquisition_framework=id_acquisition_framework, id_role=id_role, id_nomenclature_actor_role=id_nomenclature_actor_role, ).one()) except exc.NoResultFound: return None
class 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(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]))
def add_nomenclature(module_code): path_nomenclature = CONFIG_PATH + '/' + module_code + '/nomenclature.json' if not os.path.exists(path_nomenclature): print("Il n'y a pas de nomenclature à insérer pour ce module") return nomenclature = json_from_file(path_nomenclature, None) if not nomenclature: print( 'Il y a un problème avec le fichier {}'.format(path_nomenclature)) return for data in nomenclature.get('types', []): nomenclature_type = None try: nomenclature_type = ( DB.session.query(BibNomenclaturesTypes).filter( data.get('mnemonique') == BibNomenclaturesTypes.mnemonique).one()) except Exception: pass if nomenclature_type: print('no insert type', nomenclature_type) continue data['label_fr'] = data.get('label_fr') or data['label_default'] data['definition_fr'] = data.get( 'definition_fr') or data['definition_default'] data['source'] = data.get('source') or 'monitoring' data['statut'] = data.get('statut') or 'Validation en cours' nomenclature_type = BibNomenclaturesTypes(**data) DB.session.add(nomenclature_type) DB.session.commit() for data in nomenclature['nomenclatures']: nomenclature = None try: nomenclature = (DB.session.query(TNomenclatures).join( BibNomenclaturesTypes, BibNomenclaturesTypes.id_type == TNomenclatures.id_type).filter( and_( data.get('cd_nomenclature') == TNomenclatures.cd_nomenclature, data.get('type') == BibNomenclaturesTypes.mnemonique)).one()) except Exception as e: pass if nomenclature: # TODO make update print('nomenclature {} - {} already exist'.format( nomenclature.cd_nomenclature, nomenclature.label_default)) continue id_type = None try: id_type = (DB.session.query(BibNomenclaturesTypes.id_type).filter( BibNomenclaturesTypes.mnemonique == data['type']).one())[0] except Exception: pass if not id_type: print( 'probleme de type avec mnemonique="{}" pour la nomenclature {}' .format(data['type'], data)) continue data['label_fr'] = data.get('label_fr') or data['label_default'] data['definition_fr'] = data.get( 'definition_fr') or data['definition_default'] data['source'] = data.get('source') or 'monitoring' data['statut'] = data.get('statut') or 'Validation en cours' data['active'] = True data['id_type'] = id_type data.pop('type') nomenclature = TNomenclatures(**data) DB.session.add(nomenclature) DB.session.commit()
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()]))
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.Date) 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") 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="select", cascade="all,delete-orphan", uselist=True, backref=DB.backref("acquisition_framework", lazy="select"), ) def get_object_cruved( self, info_role, user_cruved ): """ Return the user's cruved for a Model instance. Use in the map-list interface to allow or not an action params: - user_cruved: object retourner by cruved_for_user_in_app(user) {'C': '2', 'R':'3' etc...} - id_object (int): id de l'objet sur lqurqul on veut vérifier le CRUVED (self.id_dataset/ self.id_ca) - id_role: identifiant de la personne qui demande la route - id_object_users_actor (list): identifiant des objects ou l'utilisateur est lui même acteur - id_object_organism_actor (list): identifiants des objects ou l'utilisateur ou son organisme sont acteurs Return: dict {'C': True, 'R': False ...} """ return { action: self.user_is_allowed_to(self.cor_af_actor, info_role, level) for action, level in user_cruved.items() } @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")) id_taxa_list = DB.Column(DB.Integer) modules = DB.relationship("TModules", secondary=cor_module_dataset, lazy="select") creator = DB.relationship("User", lazy="joined") nomenclature_data_type = DB.relationship( TNomenclatures, lazy="select", primaryjoin=(TNomenclatures.id_nomenclature == id_nomenclature_data_type), ) nomenclature_dataset_objectif = DB.relationship( TNomenclatures, lazy="select", primaryjoin=(TNomenclatures.id_nomenclature == id_nomenclature_dataset_objectif), ) nomenclature_collecting_method = DB.relationship( TNomenclatures, lazy="select", primaryjoin=( TNomenclatures.id_nomenclature == id_nomenclature_collecting_method ), ) nomenclature_data_origin = DB.relationship( TNomenclatures, lazy="select", primaryjoin=(TNomenclatures.id_nomenclature == id_nomenclature_data_origin), ) nomenclature_source_status = DB.relationship( TNomenclatures, lazy="select", primaryjoin=(TNomenclatures.id_nomenclature == id_nomenclature_source_status), ) nomenclature_resource_type = DB.relationship( TNomenclatures, lazy="select", primaryjoin=(TNomenclatures.id_nomenclature == 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") ) def __str__(self): return self.dataset_name def get_object_cruved( self, info_role, user_cruved ): """ Return the user's cruved for a Model instance. Use in the map-list interface to allow or not an action params: - user_cruved: object retourner by cruved_for_user_in_app(user) {'C': '2', 'R':'3' etc...} - id_object (int): id de l'objet sur lqurqul on veut vérifier le CRUVED (self.id_dataset/ self.id_ca) - id_role: identifiant de la personne qui demande la route - id_object_users_actor (list): identifiant des objects ou l'utilisateur est lui même acteur - id_object_organism_actor (list): identifiants des objects ou l'utilisateur ou son organisme sont acteurs Return: dict {'C': True, 'R': False ...} """ return { action: self.user_is_allowed_to(self.cor_dataset_actor, info_role, level) for action, level in user_cruved.items() } @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()]))
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 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