class User(db.Model):
__tablename__ = "users"
__table_args__ = (db.UniqueConstraint('email', 'tenant_id'), )
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(60), nullable=False)
name = db.Column(db.String(30), nullable=False)
_password = db.Column("password", db.String(), nullable=False)
is_admin = db.Column(db.Boolean(), nullable=False)
is_owner = db.Column(db.Boolean(), nullable=False, default=False)
created_at = db.Column(db.DateTime(timezone=False),
nullable=False,
server_default=now())
expires_on = db.Column(db.DateTime(), nullable=False, default=get_expiry)
tenant_id = db.Column(db.Integer,
db.ForeignKey('tenants.id', ondelete="CASCADE"),
nullable=False)
@hybrid_property
def password(self):
return self._password
@password.setter
def password(self, password):
self._password = bcrypt.generate_password_hash(password).decode(
'utf-8')
def __repr__(self):
return f"email:{self.email} -- id:{self.id} -- tenant_id:{self.tenant_id}"
class display(db.Model):
# Anzeigen: Definieren mittels ihrer Konfiguration, wie eine DisplayGroup angezeigt wird.
__tablename__ = "display"
# Daten
id = db.Column(db.Integer, primary_key=True)
title_de = db.Column(db.Text, unique=True)
title_en = db.Column(db.Text)
# Titel
is_deprecated = db.Column(db.Boolean())
# Handelt es sich um ein Display, das nicht mehr verwendet werden soll?
deprecated_by_id = db.Column(db.Integer, db.ForeignKey('display.id'))
is_OFP = db.Column(db.Boolean())
# Wird dieses Display auf der ersten Seite angezeigt?
weight = db.Column(db.Integer)
# Determines how far up top an item is in list
# Relationships
groupLink = db.relationship("displayGroupHasDisplay")
#deprecated_by = db.relationship("display")
# Constructor
def __init__(self, title_de, title_en=None):
self.is_deprecated = False
self.is_OFP = False
self.title_de = title_de
self.title_en = title_en
class Calendar(db.Model):
"""Model for the calendar table"""
__tablename__ = 'Calendar'
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(50), nullable=False)
facility = db.Column(db.String(50))
integrator = db.Column(db.String(50))
totalTime = db.Column(db.Integer())
startDate = db.Column(db.DateTime(), nullable=False)
private = db.Column(db.Boolean())
title = db.Column(db.String(50))
requestId = db.Column(db.Integer())
rangeId = db.Column(db.Integer())
beam = db.Column(db.Boolean())
energy = db.Column(db.Float())
def create_entry(self):
result = ""
try:
db.session.add(self)
db.session.commit()
result = {'success': True}
except Exception as e:
print(e)
result = {
'error': "Unable to create calendar entry",
'success': False
}
return result
def __repr__(self):
return "<Calendar(username=%s)>" % (self.username)
class Collection(db.Model):
__tablename__ = "collections"
collection_id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.String(), nullable = False)
owner_id = db.Column(db.Integer,db.ForeignKey('users.id'), nullable=False)
description = db.Column(db.String())
collaborative = db.Column(db.Boolean(), nullable=False)
public = db.Column(db.Boolean(), nullable=False)
collection_playlists = db.relationship('Playlist', secondary=collection_playlists, backref=db.backref('collection_playlists', lazy='dynamic'))
class requests(db.Model):
"""Model for the Requests table"""
__tablename__ = 'requests'
name = db.Column(db.String(50))
email = db.Column(db.String(128))
cell = db.Column(db.String(15))
company = db.Column(db.String(30))
integrator = db.Column(db.String(30))
funding_contact = db.Column(db.String(50))
address = db.Column(db.String(128))
city = db.Column(db.String(50))
state = db.Column(db.String(30))
zipcode = db.Column(db.Integer())
approved_integrator = db.Column(db.Boolean())
approved_facility = db.Column(db.Boolean())
facility = db.Column(db.String(30))
ion = db.Column(db.String(30))
energy = db.Column(db.Float())
id = db.Column(db.Integer(), primary_key=True)
funding_cell = db.Column(db.String(15))
funding_email = db.Column(db.String(128))
start = db.Column(db.DateTime, nullable=False)
ions = db.Column(db.ARRAY(db.Integer()))
comments = db.Column(db.String(200))
po_number = db.Column(db.Integer())
username = db.Column(db.String(200))
beam_time = db.Column(db.Integer())
scheduled_start = db.Column(db.DateTime)
integrator_comment = db.Column(db.String(200))
modified = db.Column(db.Boolean())
date_of_request = db.Column(db.DateTime)
status = db.Column(db.String(40))
rejected = db.Column(db.Boolean())
order = db.Column(db.Integer())
request_range = db.Column(db.Integer())
priority = db.Column(db.Boolean())
ion_hours = db.Column(db.ARRAY(db.Integer()))
shifts = db.Column(db.ARRAY(db.Integer()))
hoursOn = db.Column(db.ARRAY(db.Integer()))
hoursOff = db.Column(db.ARRAY(db.Integer()))
totalHours = db.Column(db.ARRAY(db.Integer()))
personnel = db.Column(db.String(200))
title = db.Column(db.String(200))
def create_request(self):
db.session.add(self)
db.session.commit()
def __repr__(self):
return "<Beam(id=%s, name=%s, facility=%s)>" % (self.id, self.name,
self.facility)
class display(db.Model):
# Anzeigen: Definieren mittels ihrer Konfiguration, wie eine DisplayGroup angezeigt wird.
__tablename__ = "display"
# Daten
id = db.Column(db.Integer, primary_key=True)
flexstring_german = db.Column(db.Text)
flexstring_english = db.Column(db.Text)
subtitle_german = db.Column(db.Text)
subtitle_english = db.Column(db.Text)
name = db.Column(db.Text)
# Name of display. It is only for internal use and not displayed for the end-user
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
is_default = db.Column(db.Boolean())
# Handelt es ich um das Default-Display einer Kategorie? Dieses zeigt die Konfiguration direkt als Freitext an. Text und Untertitel sind nicht zugelassen.
is_deprecated = db.Column(db.Boolean())
# Handelt es sich um ein Display, das nicht mehr verwendet werden soll?
deprecated_by_id = db.Column(db.Integer, db.ForeignKey('display.id'))
is_OFP = db.Column(db.Boolean())
# Wird dieses Display auf der ersten Seite angezeigt?
varlist = db.Column(db.JSON)
# Liste der Variablen
is_mergable = db.Column(db.Boolean())
# Kann dieses display gemerged werden (hängt von varlist ab)
weight = db.Column(db.Integer)
# Determines how far up top an item is in list
# Relationships
category = db.relationship("categories")
groupLink = db.relationship("displayGroupHasDisplay")
#deprecated_by = db.relationship("display")
# Constructor
def __init__(self,
flexstring_german,
subtitle_german,
category_id=None,
is_default=False,
varlist={}):
self.flexstring_german = flexstring_german
self.subtitle_german = subtitle_german
self.category_id = category_id
self.is_default = is_default
self.is_deprecated = False
self.is_OFP = False
self.is_Mergable = False
self.weight = 0
self.varlist = varlist
class User(db.Model,
UserMixin): # Creating a Users class inheriting from db.Model
__tablename__ = "users" # Explicitly naming the table "users"
id = db.Column(
db.Integer,
primary_key=True) # There is an id column and it is the primary key
email = db.Column(
db.String(), nullable=False,
unique=True) # Email column, string and it must be unique
password = db.Column(
db.String(),
nullable=False) # The password is a string and must be present
profile = db.relationship(
'Profile', backref=backref(
'user',
uselist=False)) # Creating the relationship to the profile table
playlists = db.relationship('Playlist',
cascade='all, delete',
backref='owner')
collections = db.relationship('Collection',
cascade='all, delete',
backref='owner')
is_admin = db.Column(db.Boolean(), default=False)
def __repr__(
self): # When printing the model we will see its email attribute
return f"<User {self.email}>"
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(64), nullable=True)
email_verified = db.Column(db.Boolean(), nullable=False, default=False)
class Ranges(db.Model):
"""Model for the facility table"""
__tablename__ = 'Ranges'
id = db.Column(db.Integer(), primary_key=True)
org_id = db.Column(db.Integer())
start_date = db.Column(db.DateTime())
facility = db.Column(db.String())
hours = db.Column(db.Integer())
scheduled = db.Column(db.Boolean())
def create_range(self):
result = ""
try:
db.session.add(self)
db.session.commit()
result = {'success': True}
except Exception as e:
print(e)
result = {
'error': "Unable to create range entry",
'success': False
}
return result
def __repr__(self):
return "<Range(id=%s, facility=%s)>" % (self.org_id, self.facility)
class Person(db.Model):
id = db.Column(db.Integer, primary_key=True)
nick = db.Column(db.String(128))
email = db.Column(db.String(128), unique=True)
tshirt = db.Column(db.String(128))
price = db.Column(db.Integer())
days = db.Column(db.String(128))
paid = db.Column(db.Boolean())
token = db.Column(db.String(32))
def __init__(self, nick, email, tshirt, price, days):
self.nick = nick
self.email = email
self.tshirt = tshirt
self.price = price
self.days = days
self.token = hashlib.sha256(os.urandom(32)).hexdigest()
self.paid = False
def serialize(self):
r = vars(self)
if "_sa_instance_state" in r:
del r["_sa_instance_state"]
return r
class Post(db.Model):
__tablename__ = 'post'
postid = db.Column(db.Integer, primary_key=True)
post_name = db.Column(db.String(), nullable=False)
post_description = db.Column(db.String(), nullable=False)
account_active = db.Column(db.Boolean(), nullable=False)
front_end = db.Column(db.Boolean(), nullable=False)
back_end = db.Column(db.Boolean(), nullable=False)
full_stack = db.Column(db.Boolean(), nullable=False)
completed = db.Column(db.Boolean(), nullable=False)
profile_id = db.Column(db.Integer,
db.ForeignKey("profiles.profileid"),
nullable=False)
post_github = db.Column(db.String(), nullable=False)
messages = db.relationship("Messages", backref="post", lazy="dynamic")
class User(db.Model):
__tablename__ = 'users'
userid = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String())
isadmin = db.Column(db.Boolean())
firstname = db.Column(db.String())
lastname = db.Column(db.String())
phone = db.Column(db.Integer)
def __init__(self, firstname, lastname, email, phone, isadmin):
self.email = email
self.isadmin = isadmin
self.firstname = firstname
self.lastname = lastname
self.phone = phone
def to_dict(self):
return {
"userid": self.userid,
"firstname": self.firstname,
"lastname": self.lastname,
"email": self.email,
"isadmin": self.isadmin,
"phone": self.phone,
}
class SurveyWRSSummary(db.Model):
__tablename__ = 'survey_wrs_summary'
id = db.Column(db.Integer, primary_key=True)
year = db.Column(db.String(4), nullable=False)
post = db.Column(db.Boolean())
question = db.Column(db.String(128), nullable=False)
value = db.Column(db.String(16), nullable=False)
category_id = db.Column(db.Integer, db.ForeignKey('survey_categories.id'))
class Invite(db.Model):
id = db.Column(db.Integer, primary_key=True)
sender_id = db.Column(db.String, db.ForeignKey('user.id'))
recipient_id = db.Column(db.Integer, db.ForeignKey('user.id'))
heading = db.Column(db.String())
date_time = db.Column(db.String())
deadline = db.Column(db.String())
host_name = db.Column(db.String())
paragraph = db.Column(db.String())
details = db.Column(db.String())
accepted = db.Column(db.Boolean())
rejected = db.Column(db.Boolean())
aor = db.relationship('Action', backref='invite', lazy='dynamic')
time = db.Column(db.Date, index=True, default=datetime.utcnow())
def __repr__(self):
return 'Invite {} {} {} {}'.format(self.date_time, self.host_name,
self.paragraph, self.details)
class Track(db.Model):
__tablename__ = "tracks"
track_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(), nullable=False)
track_num = db.Column(db.Integer, nullable=False)
album_id = db.Column(db.Integer, db.ForeignKey('albums.album_id'))
disc_num = db.Column(db.Integer, nullable=False)
duration_ms = db.Column(db.Integer, nullable=False)
explicit = db.Column(db.Boolean(), nullable=False)
class Profile(db.Model):
__tablename__ = 'profiles'
profileid = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), nullable=False)
fname = db.Column(db.String(), nullable=False)
lname = db.Column(db.String(), nullable=False)
account_active = db.Column(db.Boolean(), default=True)
equipment = db.relationship("Equipment", backref="profile", lazy='dynamic')
equipment_order = db.relationship("EquipmentOrder", backref="profile")
admin = db.Column(db.Boolean(), default=False)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
profile_image = db.relationship("ProfileImages",
backref="profile",
uselist=False)
equipment = db.relationship("Equipment", cascade="all, delete")
def __repr__(self):
return f"<Profile {self.username}>"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
token = db.Column(db.String(200))
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
class Profiles(db.Model):
__tablename__ = 'profiles'
profileid = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), nullable=False)
fname = db.Column(db.String(), nullable=False)
lname = db.Column(db.String(), nullable=False)
account_active = db.Column(db.Boolean(), default=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
# post = db.relationship("Post", backref="profile", lazy="dynamic")
post = db.relationship("Post", backref="profile", lazy="raise")
class Profiles(db.Model):
__tablename__ = 'profiles'
profileid = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), nullable=False)
fname = db.Column(db.String(), nullable=False)
lname = db.Column(db.String(), nullable=False)
account_active = db.Column(db.Boolean(), default=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
profile_image = db.relationship("ProfileImage",
backref="profile",
uselist=False)
post = db.relationship("Post", backref="profile", lazy="dynamic")
github = db.Column(db.String(), nullable=False)
front_end = db.Column(db.Boolean(), nullable=False)
back_end = db.Column(db.Boolean(), nullable=False)
full_stack = db.Column(db.Boolean(), nullable=False)
messages = db.relationship("Messages", backref="profile")
post = db.relationship("Post", cascade="all, delete")
admin = db.Column(db.Boolean(), default=False)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(), nullable=False, unique=True)
password = db.Column(db.String(), nullable=False)
isAdmin = db.Column(db.Boolean(), nullable=False)
store = db.relationship("Store", backref=backref("user", uselist=False))
def __repr__(self):
return f"<User {self.email}>"
class Menu(db.Model):
__tablename__ = "menu"
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String())
price = db.Column(db.Integer())
vegetarian = db.Column(db.Boolean())
order = db.relationship("Order", backref="menu", lazy="dynamic")
def __repr__(self):
return f"<Book {self.title}>"
class districts(db.Model):
__tablename__ = "districts"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
name_de = db.Column(db.String(100))
incidence = db.Column(db.Integer)
color = db.Column(db.String(10))
links = db.Column(db.JSON)
geometry = db.Column(db.JSON)
region_id = db.Column(db.Integer, db.ForeignKey('regions.id'))
region = db.relationship("regions")
notes = db.Column(db.Text)
category = db.Column(db.String(20))
deactivate_region = db.Column(db.Boolean())
""" Example for links-JSON:
[
{
"display": "string",
"link": "string"
}
]
"""
groupLink = db.relationship("districtHasGroup")
cron = db.relationship("cron", secondary=districtHasCron, back_populates="districts")
def __init__(self, id, name, incidence, color, links, geometry, category):
self.id = id
self.name = name
self.incidence = incidence
self.color = color
self.links = links
self.geometry = geometry
self.category = category
self.name_de = name
self.deactivate_region = False
di = districts.query.filter(districts.name == name).all()
# Kreisfreie Städte und Landkreise unterscheiden
for d in di:
# change existing name_de
if d.name_de == name:
if d.category == "Landkreis":
d.name_de += " (Kreis)"
elif d.category == "Kreisfreie Stadt":
d.name_de += " (Stadt)"
else:
d.name_de += " ("+d.category+")"
if di:
#set new name_de
if category == "Landkreis":
self.name_de += " (Kreis)"
elif category == "Kreisfreie Stadt":
self.name_de += " (Stadt)"
else:
self.name_de += " ("+category+")"
class Order(db.Model):
__tablename__ = "orders"
id = db.Column(db.Integer, primary_key=True)
shipping_id = db.Column(db.Integer, db.ForeignKey("ordershipping.id"))
date_ordered = db.Column(db.DateTime,
default=datetime.now(),
nullable=False)
shipped = db.Column(db.Boolean(), default=False)
def __repr__(self):
return f"<Order {self.id}>"
class Users(UserMixin, db.Model):
"""Model for the users table"""
__tablename__ = 'Users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String())
password = db.Column(db.String())
first_name = db.Column(db.String())
last_name = db.Column(db.String())
affiliation = db.Column(db.String())
user_type = db.Column(db.String())
phone = db.Column(db.String())
email = db.Column(db.String())
org_id = db.Column(db.Integer)
isAuthenticatedAdmin = db.Column(db.Boolean())
isAdmin = db.Column(db.Boolean())
isAuthenticatedIntegrator = db.Column(db.Boolean())
def set_password(self, password):
self.password = bcrypt.generate_password_hash(
password.encode('utf-8')).decode('utf-8')
def check_password(self, password):
return bcrypt.check_password_hash(self.password, password)
def register_user(self):
result = ""
try:
db.session.add(self)
db.session.commit()
result = {'success': True}
except Exception as e:
print(e)
result = {'error': "Unable to register user", 'success': False}
return result
def __repr__(self):
return "<User(id=%s, first_name=%s, last_name=%s)>" % (
self.id, self.first_name, self.last_name)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(), nullable=False, unique=True)
password = db.Column(db.String(), nullable=False)
admin = db.Column(db.Boolean(), nullable=True)
# shipping = db.Column(db.Integer, db.ForeignKey("ordershipping.id"))
# shipping = db.relationship("OrderShipping", backref="ordershipping.id")
def __repr__(self):
return f"<User {self.id}: {self.email}>"
class Users(db.Model):
__tablename__ = 'users'
userid =db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(), nullable=False)
fname = db.Column(db.String(), nullable=False)
lname = db.Column(db.String(), nullable=False)
profile_pic = db.Column(db.String())
account_active = db.Column(db.Boolean(), default = True)
account_id = db.Column(db.Integer, db.ForeignKey("accounts.id"), nullable=False)
def __repr__(self):
return f"<User {self.username}>"
class Uploads(db.Model):
__tablename__ = 'uploads'
__table_args__ = tuple(
UniqueConstraint('uploader',
'ipfs_hash',
name='uploader_ipfs_hash_unique_constraint'))
id = db.Column(db.Integer, primary_key=True)
uploader = db.Column(db.Integer, db.ForeignKey('credentials.id'))
ipfs_hash = db.Column(db.Text())
original_name = db.Column(db.Text())
parent_hash = db.Column(db.Text())
is_avatar = db.Column(db.Boolean(), default=False)
date = db.Column(db.DateTime, server_default=func.now())
class User(UserMixin, db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.now)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
name = db.Column(db.String(1000))
membership = db.Column(db.String(1000))
valid = db.Column(db.String(1000))
valid_till = db.Column(db.String(1000))
is_admin = db.Column(db.Boolean())
bookings = db.relationship("Bookings", backref="user", lazy="dynamic")
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(), nullable=False, unique=True)
password = db.Column(db.String(), nullable=False)
first_name = db.Column(db.String(), nullable=False)
last_name = db.Column(db.String(), nullable=False)
admin = db.Column(db.Boolean(), default=False)
order = db.relationship("Order", backref="users")
def __repr__(self):
return f"<User {self.email}>"
class districts(db.Model):
__tablename__ = "districts"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
name_de = db.Column(db.String(100))
incidence = db.Column(db.Integer)
color = db.Column(db.String(10))
#links = db.Column(db.JSON)
geometry = db.Column(db.JSON)
region_id = db.Column(db.Integer, db.ForeignKey('regions.id'))
category = db.Column(db.String(20))
deactivate_region = db.Column(db.Boolean())
lastModified = db.Column(db.String(40))
mainLink = db.Column(db.Text)
requestCounter = db.Column(db.BigInteger)
# Relationships
region = db.relationship("regions")
links = db.relationship("links")
groupLink = db.relationship("districtHasGroup")
devices = db.relationship("devices", secondary="deviceHasDistrict", back_populates="districts")
def __init__(self, id, name, incidence, color, geometry, category):
self.id = id
self.name = name
self.incidence = incidence
self.color = color
self.geometry = geometry
self.category = category
self.name_de = name
self.deactivate_region = False
self.requestCounter = 0
di = districts.query.filter(districts.name == name).all()
# Kreisfreie Städte und Landkreise unterscheiden
for d in di:
# change existing name_de
if d.name_de == name:
if d.category == "Landkreis":
d.name_de += " (Kreis)"
elif d.category == "Kreisfreie Stadt":
d.name_de += " (Stadt)"
else:
d.name_de += " ("+d.category+")"
if di:
#set new name_de
if category == "Landkreis":
self.name_de += " (Kreis)"
elif category == "Kreisfreie Stadt":
self.name_de += " (Stadt)"
else:
self.name_de += " ("+category+")"
