class USER(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), unique=True, nullable=False)
role = db.Column(db.Integer, nullable=False, default=2)
password = db.Column(db.String(256), nullable=False)
dep_id = db.Column(db.Integer, db.ForeignKey('DEP.id'))
deps = db.relationship('DEP', backref='user')
class Vector(db.Model):
id = db.Column(db.Integer, primary_key=True)
constellation_id = db.Column(db.Integer, db.ForeignKey('constellation.id'))
stars = db.relationship('Star',
secondary=stars,
backref=db.backref('vectors', lazy='dynamic'))
a = db.Column(db.Integer, db.ForeignKey('star.id'))
b = db.Column(db.Integer, db.ForeignKey('star.id'))
def __init__(self, constellation_id, a, b):
self.constellation_id = constellation_id
self.a = a
self.b = b
def __repr__(self):
return "<vector: {}>".format(self.id)
def __str__(self):
return "Vector: {} to {} from constellation {}".format(
self.a, self.b, self.constellation_id)
def to_array(self):
return [self.a, self.b]
class ObservationModel(ObserverMixinModel, TimestampMixinModel, db.Model):
"""Table des observations"""
__tablename__ = "t_obstax"
__table_args__ = {"schema": "gnc_obstax"}
id_observation = db.Column(db.Integer, primary_key=True, unique=True)
uuid_sinp = db.Column(UUID(as_uuid=True), nullable=False, unique=True)
id_program = db.Column(
db.Integer,
db.ForeignKey(ProgramsModel.id_program, ondelete="SET NULL"),
nullable=False,
)
cd_nom = db.Column(db.Integer, nullable=False)
# String(1000) taken from taxonomie.bib_noms:
name = db.Column(db.String(1000), nullable=False)
date = db.Column(db.Date, nullable=False)
count = db.Column(db.Integer)
comment = db.Column(db.String(300))
# FIXME: remove nullable prop from ObservationModel.municipality once debugged
municipality = db.Column(db.String(100), nullable=True)
geom = db.Column(Geometry("POINT", 4326))
json_data = db.Column(JSONB, nullable=True)
program_ref = db.relationship("ProgramsModel",
backref=db.backref("t_obstax",
lazy="dynamic"))
class AboutInfo(db.Model):
__tablename__ = 'AboutInfo'
aboutinfo_id = db.Column(db.Integer, primary_key=True)
first = db.Column(db.String(100))
last = db.Column(db.String(100))
position = db.Column(db.String(100))
email = db.Column(db.String(100))
phone = db.Column(db.String(30))
img_url = db.Column(db.String(1000))
date = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
history = db.relationship('History',
backref='aboutinfo',
lazy='dynamic',
order_by='History.date.desc()')
def __init__(self, first, last, position, email, phone, img_url):
self.first = first
self.last = last
self.position = position
self.email = email
self.phone = phone
self.img_url = img_url
class Roles(db.Model):
__tablename__ = 'Roles'
role_id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(100), unique=True)
edit_date = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
emails = db.relationship('Emails',
secondary=role_email,
backref=db.backref('roles', lazy='dynamic'),
lazy='dynamic')
def __init__(self, role_name):
self.role_name = role_name
def add_email(self, email):
if not self.has_email(email):
self.emails.append(email)
def remove_email(self, email):
if self.has_email(email):
self.emails.remove(email)
def has_email(self, email):
return self.emails.filter(
Emails.email_id == email.email_id).count() > 0
class Event(db.Model):
__tablename__ = 'events'
event_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120))
details = db.Column(db.UnicodeText)
start = db.Column(db.String(80))
end = db.Column(db.String(80))
capacity = db.Column(db.Integer)
status = db.Column(db.String(80))
creater = db.Column(db.String(80))
fee = db.Column(db.Integer)
early_period = db.Column(db.Integer)
users = db.relationship('User',secondary=event_realation,
backref=db.backref('event_users_all', lazy='dynamic'))
def __init__(self,title,details,start,end,capacity,status, creater,fee, early_period):
self.title = title
self.details = details
self.start = start
self.end = end
self.capacity = capacity
self.status = status
self.creater = creater
self.fee = fee
self.early_period = early_period
def __repr__(self):
return '<Event: %r>'%self.title
class Building(ModelBase):
"""
Establishes a building in the database.
lat, lng, place_id, state etc. are all pulled from Google maps
"""
__tablename__ = 'building'
lat = db.Column(db.Float())
lng = db.Column(db.Float())
formatted_address = db.Column(db.String())
place_id = db.Column(db.String())
state = db.Column(db.String())
country = db.Column(db.String())
locality = db.Column(db.String())
postal_code = db.Column(db.String())
route = db.Column(db.String())
street_number = db.Column(db.String())
url = db.Column(db.String())
roof_area_estimation = db.relationship(
'RoofAreaEstimation',
backref='building',
lazy='dynamic',
foreign_keys='RoofAreaEstimation.building_id')
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
tags = db.relationship('Tag', backref='category', lazy='dynamic')
def __repr__(self):
return self.name
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
product_nr = db.Column(db.String(50), index=True, unique=True)
name = db.Column(db.String(100), index=True)
price = db.Column(db.Integer)
transactions = db.relationship('Transaction',
backref='product',
lazy='dynamic',
foreign_keys='Transaction.product_id')
def __repr__(self):
return '<Product {} | {} | {}>'.format(self.id, self.product_nr,
self.name)
@property
def serialize(self):
"""Return object data in serializeable format"""
return {
'id': self.id,
'product_nr': self.product_nr,
'name': self.name,
'price': self.price
}
def storageData(self):
quantityAtStockLocations = {}
transactions = self.transactions.all()
for t in transactions:
city = StockLocation.query.get(t.stock_nr).city
try:
if t.inbound:
quantityAtStockLocations[
city] = quantityAtStockLocations[city] + t.quantity
else:
quantityAtStockLocations[
city] = quantityAtStockLocations[city] - t.quantity
except KeyError as e:
quantityAtStockLocations[city] = 0
if t.inbound:
quantityAtStockLocations[
city] = quantityAtStockLocations[city] + t.quantity
else:
quantityAtStockLocations[
city] = quantityAtStockLocations[city] - t.quantity
stockLocations = StockLocation.query.all()
outdata = []
for sl in stockLocations:
stockLocation = {}
stockLocation['stockLocation'] = sl.city
try:
stockLocation['quantity'] = quantityAtStockLocations[sl.city]
outdata.append(stockLocation)
except KeyError as e:
# print("Did not find any data for this location: " + sl.city)
pass
return outdata
class CorTaxonAttribut(serializableModel, db.Model):
__tablename__ = 'cor_taxon_attribut'
__table_args__ = {'schema': 'taxonomie'}
id_attribut = db.Column(db.Integer,
ForeignKey("taxonomie.bib_attributs.id_attribut"),
nullable=False,
primary_key=True)
cd_ref = db.Column(db.Integer,
ForeignKey("taxonomie.bib_noms.cd_ref"),
nullable=False,
primary_key=True)
valeur_attribut = db.Column(db.Text, nullable=False)
bib_nom = db.relationship("BibNoms")
bib_attribut = db.relationship("BibAttributs")
def __repr__(self):
return '<CorTaxonAttribut %r>' % self.valeur_attribut
class Transaction(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
ticket_amount = db.Column(db.Integer)
activity = db.Column(db.String(255))
datetime = db.Column(db.DateTime, default=datetime.datetime.utcnow)
user = db.relationship("User", backref="user_transactions")
class Agreement(db.Model):
__table_args__ = {'extend_existing': True}
__tablename__ = 'agreement'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
nullable=False)
created_by = db.Column(db.Integer, db.ForeignKey('user.id'))
no_agreement = db.Column(db.Integer, nullable=False, unique=True)
id_person = db.Column(db.Integer,
db.ForeignKey('person.id'),
nullable=False)
id_type_agreement = db.Column(db.Integer,
db.ForeignKey('kind_agreement.id'))
id_person_agreement = db.Column(db.Integer, db.ForeignKey('person.id'))
id_object_agreement = db.Column(db.Integer,
db.ForeignKey('objectAgreement.id'),
nullable=False)
file_pdf = db.Column(db.LargeBinary)
person = db.relationship("Person", foreign_keys=[id_person])
person_agreement = db.relationship("Person",
foreign_keys=[id_person_agreement])
def __init__(self,
no_agreement=None,
created_by=None,
id_person=None,
id_type_agreement=None,
id_person_agreement=None,
id_object_agreement=None,
file_pdf=None):
if no_agreement:
self.no_agreement = no_agreement
if created_by:
self.created_by = created_by
if id_person:
self.id_person = id_person
if id_type_agreement:
self.id_type_agreement = id_type_agreement
if id_object_agreement:
self.id_object_agreement = id_object_agreement
if id_person_agreement:
self.id_person_agreement = id_person_agreement
if file_pdf:
self.file_pdf = file_pdf
class modelChat(db.Model):
__tablename__ = 'chat'
id_chat = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer, db.ForeignKey('user.id'))
mensagem = db.Column(db.Text())
data_hora = db.Column(db.DateTime())
activate = db.Column(db.Boolean())
chat_and_usuario = db.relationship('modelUsuario')
class Recipe(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(140))
ingredients = db.relationship('Ingredient',
secondary=ingredients,
lazy='subquery',
backref=db.backref('pages', lazy=True))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class Article(db.Model):
__tablename__ = 'article'
article_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(20), nullable=False)
content = db.Column(db.Text, nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = db.relationship('User', backref=db.backref('articles'))
class Server(db.Model):
__tablename__ = 'servers'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
server_token = db.Column(db.String, unique=True)
server_id = db.Column(db.String)
server_name = db.Column(db.String)
users = db.relationship(User, backref='server')
class InsightComments(db.Model):
__tablename__ = 'insight_comments'
id = db.Column(db.Integer, primary_key=True)
source_id = db.Column(db.Integer, ForeignKey('insight.id'))
comment_body = db.Column(db.Text)
creator_id = db.Column(db.Integer, ForeignKey('users.user_id'))
create_date = db.Column(db.DateTime, default=datetime.utcnow)
user = db.relationship('User')
class Enterprise(db.Model):
__tablename__ = 'enterprise'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(80), nullable=False)
enterprise_id = db.Column(db.String(20), nullable=False, unique=True)
pills = db.relationship('Pill', backref='enterprise', lazy=True)
class ClassroomModel(db.Model):
__tablename__ = 'classroom'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(70), unique=False, nullable=False)
teacher_id = db.Column(db.Integer,
db.ForeignKey('teacher.id'),
nullable=False)
students = db.relationship('StudentModel',
backref='classroom',
cascade="all,delete",
lazy=True)
reports = db.relationship('ReportModel',
backref='classroom',
cascade="all,delete",
lazy=True)
class Airport(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
departure = db.Column(db.String(20), nullable=False, default=datetime.utcnow())
arrival = db.Column(db.String(20), nullable=False)
flight_det = db.relationship('Flight_Details', backref='user2', lazy=True)
def __repr__(self):
return f"Airport('{self.Airport_name}','{self.departure}','{self.arrival}')"
class ShipStatus(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), index=True, nullable=False)
description = db.Column(db.String(150))
ship_ids = db.relationship('Ship', backref='ship_status', lazy='dynamic')
def __repr__(self):
return f"{self.name}"
class Generation(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True, nullable=False)
region = db.Column(db.String, unique=True, nullable=False)
games = db.Column(db.String(120), nullable=False)
pokemon = db.relationship("Pokemon",
secondary=lambda: helper_pokemon_generation,
back_populates="generation")
class Test(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), unique=True, nullable=False)
length = db.Column(db.Integer, nullable=False)
type_ = db.Column(db.String(5), nullable=False)
results = db.relationship('TestResult', backref='test')
def __repr__(self):
return f'Test {id}'
class SeparatorConcentration(db.Model):
__tablename__ = 'separator_concentration'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
component_id = db.Column(db.Integer, db.ForeignKey('separator_component.id'),
nullable=False)
concentration = db.Column(db.Float, nullable=False)
component = db.relationship("SeparatorComponent", foreign_keys=[component_id])
class VirtualProjectCatalog(db.Model):
__tablename__ = 'virtual_project_catalog'
virtual_project_id = db.Column(db.Integer, db.ForeignKey('virtual_project.id'),
nullable=False, primary_key=True)
measurement_id = db.Column(db.Integer, db.ForeignKey('measurement.id'),
nullable=False, primary_key=True)
measurement = db.relationship('Measurement', foreign_keys=[measurement_id])
class NegativeElectrodeConcentration(db.Model):
__tablename__ = 'negative_electrode_concentration'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
component_id = db.Column(db.Integer, db.ForeignKey('electrode_component.id'),
nullable=False)
concentration = db.Column(db.Float, nullable=False)
component = db.relationship("ElectrodeComponent", foreign_keys=[component_id])
class Cell(db.Model):
__tablename__ = 'cell'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cell_type_id = db.Column(db.Integer, db.ForeignKey('cell_type.id'), nullable=False)
created_date = db.Column(db.DateTime, nullable=False)
title = db.Column(db.Integer)
cell_type = db.relationship("CellType", foreign_keys=[cell_type_id])
class StudentModel(db.Model):
__tablename__ = 'student'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(70), unique=False, nullable=False)
id_number = db.Column(db.String(10), unique=False, nullable=True)
org_class = db.Column(db.String(20), unique=False, nullable=True)
gender = db.Column(db.Boolean, unique=False,
nullable=True) # True means male
phone = db.Column(db.String(12), unique=False, nullable=True)
class_id = db.Column(db.Integer,
db.ForeignKey('classroom.id'),
nullable=False)
zoom_names = db.relationship('ZoomNamesModel',
backref='student',
lazy=True)
statuses = db.relationship('StudentStatus', backref='student', lazy=True)
class ModelName(db.Model):
__table_args__ = (db.UniqueConstraint('name', 'uid'),
db.UniqueConstraint('hid', 'gid'))
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(80), nullable=False)
uid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
hid = db.Column(db.Integer, db.ForeignKey('table_name.id'), nullable=False)
gid = db.Column(db.Integer, db.ForeignKey('table_name.id'), nullable=False)
models = db.relationship('Model', backref='name', lazy=True)
class Offset(db.Model):
id = db.Column(db.Integer, primary_key=True)
x = db.Column(db.Integer)
y = db.Column(db.Integer)
glyph_name = db.Column(db.String(64))
composite_id = db.Column(db.Integer, db.ForeignKey('glyph.id'))
composite_glyph = db.relationship('Glyph', back_populates='offsets')
