class users(db.Model, UserMixin):
id = db.Column(db.Integer, db.Sequence('seq_users'), primary_key=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255))
name = db.Column(db.String(255), nullable=False)
organisation = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=True)
roles = db.relationship('roles',
secondary=users_roles,
backref=db.backref('users', lazy='dynamic')) #
preferences = db.Column(db.String(40000))
country = db.Column(db.String(50))
usercreationdate = db.Column(TIMESTAMP, default=func.now())
usercreationreason = db.Column(db.String(1000))
def __str__(self):
return "{0} ({1})".format(self.name, self.email)
def GetPref(self, prjid, name, defval):
try:
prjid = str(prjid)
tmp = json.loads(self.preferences)
if prjid not in tmp:
return defval
if isinstance(defval, int):
return int(tmp[prjid].get(name, defval))
if isinstance(defval, (float)):
return float(tmp[prjid].get(name, defval))
return tmp[prjid].get(name, defval)
except:
return defval
def SetPref(self, prjid, name, newval):
try:
prjid = str(prjid)
tmp = json.loads(self.preferences)
if prjid not in tmp:
tmp[prjid] = {}
if tmp[prjid].get(name, -99999) == newval:
return 0 # déjà la bonne valeur donc il n'y a rien à faire
except:
tmp = {}
if prjid not in tmp:
tmp[prjid] = {}
tmp[prjid][name] = newval
tmp[prjid]['ts'] = time.time()
if len(
tmp
) > 75: # si des settings pour plus de 50 projets on ne garde que les 25 plus recents
newpref = {
k: v
for k, v in tmp.items() if isinstance(v, dict) and 'ts' in v
}
ChronoSorted = [[k, v['ts']] for k, v in newpref.items()]
sorted(ChronoSorted, key=lambda r: r[1], reverse=True)
tmp = {}
for id, ts in ChronoSorted[0:50]:
tmp[id] = newpref[id]
self.preferences = json.dumps(tmp)
return 1
class roles(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True) #,db.Sequence('seq_roles')
name = db.Column(db.String(80), unique=True, nullable=False)
# description = db.Column(db.String(255))
def __str__(self):
return self.name
class Token(db.Model):
__tablename__ = "token"
id = db.Column(db.Integer, primary_key=True)
contract = db.Column(db.String)
network = db.Column(db.String)
record = db.Column(db.JSON)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class OneTimeKey(db.Model):
id = db.Column(db.Integer, primary_key=True)
owner = db.Column(db.String(50), nullable=False)
privateOTK = db.Column(db.Integer, nullable=False)
serverID = db.Column(db.Integer, nullable=False)
def __repr__(self):
return "<OTK of {}".format(self.owner)
class part_histopart_det(db.Model):
__tablename__ = 'part_histopart_det'
psampleid = db.Column(INTEGER,
db.ForeignKey('part_samples.psampleid'),
primary_key=True)
lineno = db.Column(INTEGER, primary_key=True)
depth = db.Column(DOUBLE_PRECISION)
datetime = db.Column(TIMESTAMP)
watervolume = db.Column(DOUBLE_PRECISION)
class Process(db.Model):
__tablename__ = 'process'
processid = db.Column(BIGINT, db.Sequence('seq_process'), primary_key=True)
projid = db.Column(INTEGER, db.ForeignKey('projects.projid'))
project = db.relationship("Projects")
orig_id = db.Column(VARCHAR(255))
def __str__(self):
return "{0} ({1})".format(self.orig_id, self.processid)
class Group(db.Model):
id = db.Column(db.Integer, primary_key=True)
owner = db.Column(db.String(50), nullable=False, primary_key=True)
groupname = db.Column(db.String(50), nullable=False)
members = db.Column(db.String(200), nullable=False)
prevStageKey = db.Column(db.Integer, nullable=False)
def __repr__(self):
return "<Group {}>".format(self.groupname)
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
address = db.Column(db.String(100), unique=True)
token = db.relationship('Token', backref='user')
def __init__(self, address):
self.address = address
class Images(db.Model):
__tablename__ = 'images'
imgid = db.Column(BIGINT, db.Sequence('seq_images'),
primary_key=True) # manuel ,db.Sequence('seq_images')
objid = db.Column(BIGINT, db.ForeignKey('obj_head.objid'))
imgrank = db.Column(INTEGER)
file_name = db.Column(VARCHAR(255))
orig_file_name = db.Column(VARCHAR(255))
width = db.Column(INTEGER)
height = db.Column(INTEGER)
thumb_file_name = db.Column(VARCHAR(255))
thumb_width = db.Column(INTEGER)
thumb_height = db.Column(INTEGER)
class ObjectsFields(db.Model):
__tablename__ = 'obj_field'
objfid = db.Column(BIGINT,
db.ForeignKey('obj_head.objid', ondelete="CASCADE"),
primary_key=True)
objhrel = db.relationship(
"Objects",
foreign_keys="Objects.objid",
primaryjoin="ObjectsFields.objfid==Objects.objid",
uselist=False,
backref="objfrel")
orig_id = db.Column(VARCHAR(255))
object_link = db.Column(VARCHAR(255))
class part_histocat(db.Model):
__tablename__ = 'part_histocat'
psampleid = db.Column(INTEGER,
db.ForeignKey('part_samples.psampleid'),
primary_key=True)
classif_id = db.Column(INTEGER, primary_key=True)
lineno = db.Column(INTEGER, primary_key=True)
depth = db.Column(DOUBLE_PRECISION)
datetime = db.Column(TIMESTAMP)
watervolume = db.Column(DOUBLE_PRECISION)
nbr = db.Column(DOUBLE_PRECISION)
avgesd = db.Column(DOUBLE_PRECISION)
totalbiovolume = db.Column(DOUBLE_PRECISION) # en mm3
class Task(db.Model):
__tablename__ = 'temp_tasks'
id = db.Column(db.Integer(),
db.Sequence('seq_temp_tasks'),
primary_key=True)
owner_id = db.Column(db.Integer(), db.ForeignKey('users.id'))
owner_rel = db.relationship("users")
taskclass = db.Column(db.String(80))
taskstate = db.Column(db.String(80))
taskstep = db.Column(db.Integer())
progresspct = db.Column(db.Integer())
progressmsg = db.Column(db.String())
inputparam = db.Column(db.String())
creationdate = db.Column(db.DateTime())
lastupdate = db.Column(db.DateTime())
def __str__(self):
return self.name
class ProjectsPriv(db.Model):
__tablename__ = 'projectspriv'
id = db.Column(db.Integer,
db.Sequence('seq_projectspriv'),
primary_key=True)
projid = db.Column(INTEGER,
db.ForeignKey('projects.projid', ondelete="CASCADE"),
nullable=False)
member = db.Column(db.Integer, db.ForeignKey('users.id'))
privilege = db.Column(VARCHAR(255), nullable=False)
memberrel = db.relationship("users")
refproject = db.relationship('Projects',
backref=db.backref(
'projmembers',
cascade="all, delete-orphan",
single_parent=True)) # ,cascade='delete'
def __str__(self):
return "{0} ({1})".format(self.member, self.privilege)
class Objects_cnn_features(db.Model):
__tablename__ = 'obj_cnn_features'
objcnnid = db.Column(BIGINT,
db.ForeignKey('obj_head.objid', ondelete="CASCADE"),
primary_key=True)
objhrel = db.relationship(
"Objects",
foreign_keys="Objects.objid",
primaryjoin="Objects_cnn_features.objcnnid==Objects.objid",
uselist=False,
backref="objcnnrel")
class ObjectsClassifHisto(db.Model):
__tablename__ = 'objectsclassifhisto'
objid = db.Column(BIGINT,
db.ForeignKey('obj_head.objid', ondelete="CASCADE"),
primary_key=True)
classif_date = db.Column(TIMESTAMP, primary_key=True)
classif_type = db.Column(CHAR(1)) # A : Auto, M : Manu
classif_id = db.Column(INTEGER)
classif_qual = db.Column(CHAR(1))
classif_who = db.Column(db.Integer, db.ForeignKey('users.id'))
classif_score = db.Column(DOUBLE_PRECISION)
class TempTaxo(db.Model):
__tablename__ = 'temp_taxo'
idtaxo = db.Column(VARCHAR(20), primary_key=True)
idparent = db.Column(VARCHAR(20))
name = db.Column(VARCHAR(100))
status = db.Column(CHAR(1))
typetaxo = db.Column(VARCHAR(20))
idfinal = db.Column(INTEGER)
class EcotaxaInst(db.Model):
__tablename__ = 'ecotaxainst'
id = db.Column(INTEGER, db.Sequence('seq_ecotaxainst'), primary_key=True)
name = db.Column(VARCHAR(100), nullable=False)
url = db.Column(VARCHAR(100))
laststatupdate_datetime = db.Column(TIMESTAMP(precision=0))
ecotaxa_version = db.Column(VARCHAR(10))
sharedsecret = db.Column(VARCHAR(100), nullable=False)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
name = db.Column(db.String(1000))
privID = db.Column(db.Integer, nullable=False)
token = db.Column(db.String(500))
def __repr__(self):
return '<User %r>' % self.name
class Party(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
target = db.Column(db.String(50), nullable=False)
publicID = db.Column(db.String(500), nullable=False)
side = db.Column(db.String(30), nullable=False)
user_id = db.Column(db.Integer, nullable=False)
def __repr__(self):
return '<Key %r>' % self.username
class ProjectsTaxoStat(db.Model):
__tablename__ = 'projects_taxo_stat'
projid = db.Column(INTEGER,
db.ForeignKey('projects.projid', ondelete="CASCADE"),
primary_key=True)
id = db.Column(INTEGER, primary_key=True)
nbr = db.Column(INTEGER)
nbr_v = db.Column(INTEGER)
nbr_d = db.Column(INTEGER)
nbr_p = db.Column(INTEGER)
class Samples(db.Model):
__tablename__ = 'samples'
sampleid = db.Column(BIGINT, db.Sequence('seq_samples'), primary_key=True)
projid = db.Column(INTEGER, db.ForeignKey('projects.projid'))
project = db.relationship("Projects")
orig_id = db.Column(VARCHAR(255))
latitude = db.Column(DOUBLE_PRECISION)
longitude = db.Column(DOUBLE_PRECISION)
dataportal_descriptor = db.Column(VARCHAR(8000))
def __str__(self):
return "{0} ({1})".format(self.orig_id, self.processid)
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
owner = db.Column(db.String(50), nullable=False)
sender = db.Column(db.String(50), nullable=False)
content = db.Column(db.String(1000), nullable=False)
time = db.Column(db.DateTime, nullable=False)
recipient = db.Column(db.String(500), default="")
# Goal of 'owner' : when someone connects, the server
# gives them their messages, without thinking about it
def __repr__(self):
return "<Message {}, from {}>".format(self.id, self.sender)
class users(db.Model, UserMixin):
id = db.Column(db.Integer, db.Sequence('seq_users'), primary_key=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255))
name = db.Column(db.String(255), nullable=False)
organisation = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=True)
roles = db.relationship('roles',
secondary=users_roles,
backref=db.backref('users', lazy='dynamic')) #
def __str__(self):
return "{0} ({1})".format(self.name, self.email)
class part_projects(db.Model):
__tablename__ = 'part_projects'
# pprojid = db.Column(INTEGER,db.Sequence('seq_part_projects'), primary_key=True)
# SQL Alchemy ne genere pas la sequence comme dans les autres tables précédentes, probablement un evolution
# mais genere à la place un champ de type serial qui crée une sequence associée
pprojid = db.Column(INTEGER,
db.Sequence('part_projects_pprojid_seq'),
primary_key=True)
ptitle = db.Column(VARCHAR(250), nullable=False)
rawfolder = db.Column(VARCHAR(250), nullable=False)
ownerid = db.Column(db.Integer, db.ForeignKey('users.id'))
owneridrel = db.relationship("users")
projid = db.Column(INTEGER, db.ForeignKey('projects.projid'))
project = db.relationship("Projects")
instrumtype = db.Column(VARCHAR(50))
op_name = db.Column(VARCHAR(100))
op_email = db.Column(VARCHAR(100))
cs_name = db.Column(VARCHAR(100))
cs_email = db.Column(VARCHAR(100))
do_name = db.Column(VARCHAR(100))
do_email = db.Column(VARCHAR(100))
prj_info = db.Column(VARCHAR(1000))
prj_acronym = db.Column(VARCHAR(100))
cruise = db.Column(VARCHAR(100))
ship = db.Column(VARCHAR(100))
default_instrumsn = db.Column(VARCHAR(50))
default_depthoffset = db.Column(DOUBLE_PRECISION)
public_visibility_deferral_month = db.Column(INTEGER)
public_partexport_deferral_month = db.Column(INTEGER)
public_zooexport_deferral_month = db.Column(INTEGER)
oldestsampledate = db.Column(TIMESTAMP)
def __str__(self):
return "{0} ({1})".format(self.ptitle, self.pprojid)
class part_samples(db.Model):
__tablename__ = 'part_samples'
# psampleid = db.Column(INTEGER,db.Sequence('seq_part_samples'), primary_key=True)
# SQL Alchemy ne genere pas la sequence comme dans les autres tables précédentes, probablement un evolution
# mais genere à la place un champ de type serial qui crée une sequence associée
psampleid = db.Column(INTEGER,
db.Sequence('part_samples_psampleid_seq'),
primary_key=True)
pprojid = db.Column(INTEGER, db.ForeignKey('part_projects.pprojid'))
project = db.relationship("part_projects")
profileid = db.Column(VARCHAR(250), nullable=False)
filename = db.Column(VARCHAR(250), nullable=False)
sampleid = db.Column(INTEGER, db.ForeignKey('samples.sampleid'))
sample = db.relationship("Samples")
latitude = db.Column(DOUBLE_PRECISION)
longitude = db.Column(DOUBLE_PRECISION)
organizedbydeepth = db.Column(db.Boolean())
histobrutavailable = db.Column(db.Boolean())
qualitytaxo = db.Column(VARCHAR(20))
qualitypart = db.Column(VARCHAR(20))
daterecalculhistotaxo = db.Column(TIMESTAMP)
winddir = db.Column(INTEGER)
winspeed = db.Column(INTEGER)
seastate = db.Column(INTEGER)
nebuloussness = db.Column(INTEGER)
comment = db.Column(VARCHAR(1000))
stationid = db.Column(VARCHAR(100))
firstimage = db.Column(INTEGER)
lastimg = db.Column(BIGINT)
lastimgused = db.Column(BIGINT)
bottomdepth = db.Column(INTEGER)
yoyo = db.Column(db.Boolean())
sampledate = db.Column(TIMESTAMP)
op_sample_name = db.Column(VARCHAR(100))
op_sample_email = db.Column(VARCHAR(100))
ctd_desc = db.Column(VARCHAR(1000))
ctd_origfilename = db.Column(VARCHAR(250))
ctd_import_name = db.Column(VARCHAR(100))
ctd_import_email = db.Column(VARCHAR(100))
ctd_import_datetime = db.Column(TIMESTAMP)
ctd_status = db.Column(VARCHAR(50))
instrumsn = db.Column(VARCHAR(50))
acq_aa = db.Column(DOUBLE_PRECISION)
acq_exp = db.Column(DOUBLE_PRECISION)
acq_volimage = db.Column(DOUBLE_PRECISION)
acq_depthoffset = db.Column(DOUBLE_PRECISION)
acq_pixel = db.Column(DOUBLE_PRECISION)
acq_shutterspeed = db.Column(INTEGER)
acq_smzoo = db.Column(INTEGER)
acq_exposure = db.Column(INTEGER)
acq_gain = db.Column(INTEGER)
acq_filedescription = db.Column(VARCHAR(200))
acq_eraseborder = db.Column(INTEGER)
acq_tasktype = db.Column(INTEGER)
acq_threshold = db.Column(INTEGER)
acq_choice = db.Column(INTEGER)
acq_disktype = db.Column(INTEGER)
acq_smbase = db.Column(INTEGER)
acq_ratio = db.Column(INTEGER)
acq_descent_filter = db.Column(db.Boolean())
acq_presure_gain = db.Column(DOUBLE_PRECISION)
acq_xsize = db.Column(INTEGER)
acq_ysize = db.Column(INTEGER)
acq_barcode = db.Column(VARCHAR(50))
proc_datetime = db.Column(TIMESTAMP)
proc_gamma = db.Column(DOUBLE_PRECISION)
proc_soft = db.Column(VARCHAR(250))
lisst_zscat_filename = db.Column(VARCHAR(200))
lisst_kernel = db.Column(VARCHAR(200))
lisst_year = db.Column(INTEGER)
txt_data01 = db.Column(VARCHAR(200))
txt_data02 = db.Column(VARCHAR(200))
txt_data03 = db.Column(VARCHAR(200))
txt_data04 = db.Column(VARCHAR(200))
txt_data05 = db.Column(VARCHAR(200))
txt_data06 = db.Column(VARCHAR(200))
txt_data07 = db.Column(VARCHAR(200))
txt_data08 = db.Column(VARCHAR(200))
txt_data09 = db.Column(VARCHAR(200))
txt_data10 = db.Column(VARCHAR(200))
proc_process_ratio = db.Column(INTEGER)
imp_descent_filtered_row = db.Column(INTEGER)
imp_removed_empty_slice = db.Column(INTEGER)
def __str__(self):
return "{0} ({1})".format(self.profileid, self.psampleid)
class part_ctd(db.Model):
__tablename__ = 'part_ctd'
psampleid = db.Column(INTEGER,
db.ForeignKey('part_samples.psampleid'),
primary_key=True)
lineno = db.Column(INTEGER, primary_key=True)
depth = db.Column(DOUBLE_PRECISION)
datetime = db.Column(TIMESTAMP)
chloro_fluo = db.Column(DOUBLE_PRECISION)
conductivity = db.Column(DOUBLE_PRECISION)
cpar = db.Column(DOUBLE_PRECISION)
depth_salt_water = db.Column(DOUBLE_PRECISION)
fcdom_factory = db.Column(DOUBLE_PRECISION)
in_situ_density_anomaly = db.Column(DOUBLE_PRECISION)
neutral_density = db.Column(DOUBLE_PRECISION)
nitrate = db.Column(DOUBLE_PRECISION)
oxygen_mass = db.Column(DOUBLE_PRECISION)
oxygen_vol = db.Column(DOUBLE_PRECISION)
par = db.Column(DOUBLE_PRECISION)
part_backscattering_coef_470_nm = db.Column(DOUBLE_PRECISION)
pot_temperature = db.Column(DOUBLE_PRECISION)
potential_density_anomaly = db.Column(DOUBLE_PRECISION)
potential_temperature = db.Column(DOUBLE_PRECISION)
practical_salinity = db.Column(DOUBLE_PRECISION)
practical_salinity__from_conductivity = db.Column(DOUBLE_PRECISION)
qc_flag = db.Column(INTEGER)
sound_speed_c = db.Column(DOUBLE_PRECISION)
spar = db.Column(DOUBLE_PRECISION)
temperature = db.Column(DOUBLE_PRECISION)
class part_histopart_reduit(db.Model):
__tablename__ = 'part_histopart_reduit'
psampleid = db.Column(INTEGER,
db.ForeignKey('part_samples.psampleid'),
primary_key=True)
lineno = db.Column(INTEGER, primary_key=True)
depth = db.Column(DOUBLE_PRECISION)
datetime = db.Column(TIMESTAMP)
watervolume = db.Column(DOUBLE_PRECISION)
# Ajout des colonnes classe entières
for i in range(1, 16):
setattr(part_histopart_reduit, "class%02d" % i, db.Column(INTEGER))
for i in range(1, 16):
setattr(part_histopart_reduit, "biovol%02d" % i,
db.Column(DOUBLE_PRECISION))
class part_histopart_det(db.Model):
__tablename__ = 'part_histopart_det'
psampleid = db.Column(INTEGER,
db.ForeignKey('part_samples.psampleid'),
primary_key=True)
lineno = db.Column(INTEGER, primary_key=True)
depth = db.Column(DOUBLE_PRECISION)
datetime = db.Column(TIMESTAMP)
watervolume = db.Column(DOUBLE_PRECISION)
class EcotaxaInstStat(db.Model):
__tablename__ = 'ecotaxainststat'
id_instance = db.Column(INTEGER, primary_key=True)
id_taxon = db.Column(INTEGER, primary_key=True)
nbr = db.Column(INTEGER, nullable=False)
class Taxonomy(db.Model):
__tablename__ = 'taxonomy'
id = db.Column(INTEGER, db.Sequence('seq_taxonomy'), primary_key=True)
parent_id = db.Column(INTEGER)
name = db.Column(VARCHAR(100), nullable=False)
taxotype = db.Column(CHAR(1), nullable=False,
server_default='P') # P = Phylo , M = Morpho
display_name = db.Column(VARCHAR(200))
id_source = db.Column(VARCHAR(20))
source_url = db.Column(VARCHAR(200))
source_desc = db.Column(VARCHAR(1000))
creator_email = db.Column(VARCHAR(255))
creation_datetime = db.Column(TIMESTAMP(precision=0))
lastupdate_datetime = db.Column(TIMESTAMP(precision=0))
id_instance = db.Column(INTEGER)
taxostatus = db.Column(CHAR(1), nullable=False, server_default='A')
rename_to = db.Column(INTEGER)
nbrobj = db.Column(INTEGER)
nbrobjcum = db.Column(INTEGER)
def __str__(self):
return "{0} ({1})".format(self.name, self.id)
class part_histocat_lst(db.Model):
__tablename__ = 'part_histocat_lst'
psampleid = db.Column(INTEGER,
db.ForeignKey('part_samples.psampleid'),
primary_key=True)
classif_id = db.Column(INTEGER, primary_key=True)
