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()]))
