class Details(db.Model):
__tablename__ = "details"
id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False)
update_time = db.Column(db.DATETIME)
province = db.Column(db.VARCHAR(50))
city = db.Column(db.VARCHAR(50))
nowConfirm = db.Column(db.Integer)
confirm = db.Column(db.Integer)
heal = db.Column(db.Integer)
dead = db.Column(db.Integer)
class Items(db.Model):
"""This class represents the Items table."""
__tablename__ = "Items"
postedDate = db.Column(db.DATE())
itemID = db.Column(db.Integer, primary_key=True)
buyerID = db.Column(db.Integer)
userID = db.Column(db.Integer,
db.ForeignKey('Users.userID'),
primary_key=True)
name = db.Column(db.VARCHAR(100))
category = db.Column(db.VARCHAR(100))
cost = db.Column(db.Integer)
description = db.Column(db.TEXT())
sold = db.Column(db.BOOLEAN)
class Role(db.Model): #, RoleMixin):
id = db.Column(db.INTEGER, primary_key=True)
name = db.Column(db.VARCHAR(55), unique=True)
description = db.Column(db.VARCHAR(256))
users = db.relationship('User', backref='role', uselist=False)
def __str__(self):
return self.name
def __hash__(self):
return hash(self.name)
def __repr__(self):
return '<role %r>' % (self.name)
class Forecast(db.Model):
forecast_id = db.Column(db.Integer, primary_key=True)
city_id = db.Column(db.Integer,
db.ForeignKey('city.city_id'),
nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
nullable=False)
forecast_datetime = db.Column(db.String(250), nullable=False)
forecast = db.Column(db.VARCHAR(250), nullable=False)
comment = db.Column(db.VARCHAR(250), nullable=False)
def __repr__(self):
return f"Post('{self.city_id}', '{self.forecast}')"
class Receipt(db.Model):
__tablename__ = 'receipt'
id = db.Column(db.Integer,
unique=True,
primary_key=True,
autoincrement=True)
chat_id = db.Column(db.Integer, nullable=False)
user_id = db.Column(db.VARCHAR(45), nullable=False)
stuff_name = db.Column(db.VARCHAR(45))
stuff_img = db.Column(db.VARCHAR(225))
stuff_cost = db.Column(db.Integer)
stuff_num = db.Column(db.Integer)
ref_cnt = db.Column(db.Integer)
registered_on = db.Column(db.TIMESTAMP)
class Result2(db.Model):
"""[Define model 'Result2' mapped to table 'result2']
Returns:
[type] -- [description]
"""
id_result2 = db.Column(db.Integer, primary_key=True)
mykrobe_version = db.Column(db.VARCHAR(50))
phylo_grp = db.Column(db.VARCHAR(60))
phylo_grp_covg = db.Column(db.CHAR)
phylo_grp_depth = db.Column(db.CHAR)
species = db.Column(db.VARCHAR(50))
species_covg = db.Column(db.CHAR)
species_depth = db.Column(db.CHAR)
lineage = db.Column(db.VARCHAR(50))
lineage_covg = db.Column(db.CHAR)
lineage_depth = db.Column(db.CHAR)
susceptibility = db.Column(db.VARCHAR(50))
variants = db.Column(db.VARCHAR(80))
genes = db.Column(db.VARCHAR(100))
drug = db.Column(db.VARCHAR(90))
def __repr__(self):
return '<Result2 {}>'.format(self.mykrobe_version)
class Admin(db.Model):
__tablename__ = "admin"
extend_existing = True
Id = db.Column(db.Integer, primary_key=True)
Name = db.Column(db.VARCHAR(20), unique=True)
PassWd = db.Column(db.VARCHAR(15)) # TODO larger
def __init__(self, name, pass_wd):
self.Name = name
self.PassWd = pass_wd
def __repr__(self):
return '<Admin %r:Name %r>' % (self.Id, self.Name)
class Room(db.Model):
CONSULTATION = 'consultation'
SIMPLE = 'simple'
__tablename__ = 'rooms'
mysql_character_set = 'utf8'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.VARCHAR(255))
role = db.Column(db.VARCHAR(100))
messages = db.relationship('Message', backref='room', lazy='dynamic')
groups = db.relationship('Group', secondary=group_room, back_populates='rooms')
teacher_id = db.Column(db.Integer, db.ForeignKey('users.id'))
teacher = db.relationship('User', foreign_keys=[teacher_id])
class OfflineDown(db.Model):
__tablename__ = "OfflineDown"
Did = db.Column(db.INT, primary_key=True, autoincrement=True, nullable=False)
Down_url = db.Column(db.VARCHAR(2000), nullable=False)
Total_size = db.Column(db.BIGINT)
Down_size = db.Column(db.BIGINT)
Speed = db.Column(db.BIGINT)
Last_update_time = db.Column(db.BIGINT, nullable=False)
Status = db.Column(db.INT, nullable=False, default=0)
Upload_url = db.Column(db.VARCHAR(2000), nullable=False)
uid = db.Column(db.BIGINT, db.ForeignKey('User.uid'), default=0, nullable=False)
user = db.relationship('User', backref=db.backref('downs'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.VARCHAR(64), index=True, unique=True)
email = db.Column(db.VARCHAR(128), index=True, unique=True)
password = db.Column(db.String(256))
first_name = db.Column(db.VARCHAR(64))
last_name = db.Column(db.VARCHAR(64))
score = db.Column(db.Integer, default=0)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
class Bankdetails(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
account_holder = db.Column(db.String(200), nullable=False)
account_no = db.Column(db.Integer, nullable=False)
iban = db.Column(db.VARCHAR(500), nullable=False)
iban_visible = db.Column(db.String(34), nullable=False)
bic = db.Column(
db.VARCHAR(400), nullable=False
) #Autogenerated from IBAN(https://openiban.com/validate/<IBAN>?getBIC=true)(https://openiban.com/validate/DE89370400440532013000?getBIC=true)
bic_visible = db.Column(db.String(34), nullable=False)
sepa_accepted = db.Column(db.Boolean, default=False)
sepa_date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
sepa_ref = db.Column(db.String(200), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class TbFastNews(db.Model):
__tablename__ = "tb_fast_news"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
tdate = db.Column(db.Integer)
title = db.Column(db.VARCHAR(200))
subtitle = db.Column(db.VARCHAR(150))
desc = db.Column(db.VARCHAR(200))
content = db.Column(db.Text)
author = db.Column(db.VARCHAR(45))
weight = db.Column(db.Integer)
status = db.Column(db.Integer)
created_time = db.Column(db.Integer)
last_time = db.Column(db.Integer)
pub_time = db.Column(db.Integer, default=0)
share_count = db.Column(db.Integer, default=0)
class PlanosTurmas(db.Model):
__tablename__ = 'planos_turmas'
id = db.Column(db.VARCHAR(36),
primary_key=True,
default=Util.__generate_id__())
plano_id = db.Column(
db.VARCHAR(36), db.ForeignKey('plano.id',
name='FK_planosturmas_plano'))
turma_id = db.Column(
db.VARCHAR(36), db.ForeignKey('turma.id',
name='FK_planosturmas_turma'))
def __init__(self):
self.id = Util.__generate_id__()
class PlanosModalidades(db.Model):
__tablename__ = 'planos_modalidades'
id = db.Column(db.VARCHAR(36),
primary_key=True,
default=Util.__generate_id__())
plano_id = db.Column(
db.VARCHAR(36),
db.ForeignKey('plano.id', name='FK_planosmodalidade_plano'))
modalidade_id = db.Column(
db.VARCHAR(36),
db.ForeignKey('modalidade.id', name='FK_planosmodalidade_modalidade'))
def __init__(self):
self.id = Util.__generate_id__()
class Login(db.Model):
__tablename__ = 'login'
id = db.Column(db.Integer, primary_key=True)
Username = db.Column(db.VARCHAR(200))
Password = db.Column(db.VARCHAR(200))
business = db.relationship('BusinessCategory',
backref='owner',
lazy='dynamic')
def __init__(self, Username, Password):
self.Username = Username
self.Password = Password
def __repr__(self):
return '<User %r>' % self.Username
class Location(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
address = db.Column(db.VARCHAR(500), nullable=False)
type = db.Column(db.VARCHAR(300), nullable=False)
braille = db.Column(db.BOOLEAN, nullable=False, default=0)
wheelchair = db.Column(db.BOOLEAN, nullable=False, default=0)
closed_captions = db.Column(db.BOOLEAN, nullable=False, default=0)
quiet_space = db.Column(db.BOOLEAN, nullable=False, default=0)
parking = db.Column(db.BOOLEAN, nullable=False, default=0)
# Method to debug by printing out results of creation when calling the object alone
def __repr__(self):
return 'ID: {}, Address: {}, Braille: {}, Wheelchair: {}, CC: {},' \
'Quiet Space: {}, Parking: {}'.format(self.id, self.address, self.braille, self.wheelchair,
self.closed_captions, self.quiet_space, self.parking)
class ModalidadesSalas(db.Model):
__tablename__ = 'modalidades_salas'
id = db.Column(db.VARCHAR(36),
primary_key=True,
default=Util.__generate_id__())
modalidade_id = db.Column(
db.VARCHAR(36),
db.ForeignKey('modalidade.id', name='FK_modalidadessalas_modalidade'))
sala_id = db.Column(
db.VARCHAR(36),
db.ForeignKey('sala.id', name='FK_modalidadessalas_sala'))
def __init__(self):
self.id = Util.__generate_id__()
class Tsigkeys(db.Model):
"""Model for the Domain meta data."""
__bind_key__ = 'powerdnsadmin'
__tablename__ = 'tsigkeys'
algorithm = db.Column(db.VARCHAR(length=50))
id = db.Column(db.INTEGER(), primary_key=True, nullable=False)
name = db.Column(db.VARCHAR(length=255))
secret = db.Column(db.VARCHAR(length=255))
def __init__(self, algorithm=None, name=None, secret=None):
"""Initialize properties (sql table columns)."""
self.algorithm = algorithm
self.name = name
self.secret = secret
class office(db.Model):
id = db.Column(db.INTEGER, primary_key=True)
title = db.Column(db.VARCHAR(125), nullable=False)
num_positions = db.Column(db.INTEGER)
responsibilities = db.Column(db.TEXT)
term_length_months = db.Column(db.INTEGER)
filing_fee = db.Column(db.TEXT)
partisan = db.Column(db.BOOLEAN)
age_requirements = db.Column(db.VARCHAR(100))
res_requirements = db.Column(db.TEXT)
prof_requirements = db.Column(db.TEXT)
# salary should become an integer? currently is money
salary = db.Column(db.NUMERIC)
notes = db.Column(db.TEXT)
office_rank = db.Column(db.INTEGER)
class CaseWorker(db.Model):
id = db.Column(db.INTEGER, primary_key=True)
regional_center_id = db.Column(db.INTEGER,
db.ForeignKey('regional_center.id'))
regional_center_team_id = db.Column(
db.INTEGER, db.ForeignKey('regional_center_team.id'))
first_name = db.Column(db.VARCHAR(55))
last_name = db.Column(db.VARCHAR(55))
email = db.Column(db.VARCHAR(255), default='No Email')
phone = db.Column(db.VARCHAR(15), default='No Phone Number')
status = db.Column(db.VARCHAR(15), default='active')
clients = db.relationship('Client', backref='case_worker', lazy='dynamic')
def __repr__(self):
return '<case_worker: %r %r>' % (self.first_name, self.last_name)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.VARCHAR(30), unique=True)
name = db.Column(db.VARCHAR(255))
password = db.Column(db.String(94))
role = db.Column(db.VARCHAR(30), db.ForeignKey(Role.name))
def __init__(self, username, name, password, role):
self.username = username
self.name = name
self.password = generate_password_hash(password)
self.role = role
def __repr__(self):
return f'User({self.id}, {self.username}, {self.name}, {self.role})'
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.VARCHAR(64), index=True, unique=True)
email = db.Column(db.VARCHAR(120), index=True, unique=True)
password_hash = db.Column(db.VARCHAR(128))
posts = db.relationship('Log', backref='author', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class Users(UserMixin, db.Model):
"""This table represents the user"""
__tablename__ = "Users"
fname = db.Column(db.VARCHAR(100))
lname = db.Column(db.VARCHAR(100))
password = db.Column(db.VARCHAR(100))
address = db.Column(db.VARCHAR(100))
email = db.Column(db.VARCHAR(100))
birthdate = db.Column(db.DATE())
userID = db.Column(db.Integer, primary_key=True)
# @property
# def password(self):
# """
# Prevent pasword from being accessed
# """
# raise AttributeError('password is not a readable attribute.')
#
# @password.setter
# def password(self, password):
# """
# Set password to a hashed password
# """
# self.password = password
#
def get_id(self):
"""Needed to overirde feature of parent class"""
return self.userID
def verify_password(self, password):
"""
Check if hashed password matches actual password
"""
return True # Will figure out later check_password_hash(self.password_hash, password)
def __repr__(self):
"[" \
"fname: {fname}," \
"lname: {lname}," \
"username: {username}," \
"email: {email}," \
"password: {password}," \
"address: {address}," \
"birthdate: {birthdate}," \
"userID: {userID}," \
"]".format(fname=self.fname, lname=self.lname, username=self.username,
email=self.email, password=self.password, address=self.address,
userID=self.userID)
class Admin(db.Model):
def __init__(self, code: dict):
"""
Initialize an Admin object by passing in a dictionary.
:param code: A dictionary with fields matching the Admin fields
"""
self.user = code.get('user')
__tablename__ = 'admins'
user = Column(db.VARCHAR(10), primary_key=True)
def __str__(self):
"""
String representation of a type of group member. This representation is meant to be human readable.
:return: Either a 'user' or 'admin' type of group member.
"""
return f'Admin: [user: {self.user}]'
def __repr__(self):
"""
String representation of a type of group member. This representation is meant to be machine readable.
:return: Either a 'user' or 'admin' type of group member.
"""
return '<Admin %r>' % self.user
def __eq__(self, other):
"""
Determine value equality between this object and another object.
:param other: Another object to compare to this object.
:return: True if the objects are equal, False otherwise.
"""
return self.user == other.user
class SpendingCategoryLookup(db.Model):
id = db.Column(db.Integer, primary_key=True)
card_id = db.Column(db.Integer, db.ForeignKey('card.id'))
spending_category_id = db.Column(db.Integer,
db.ForeignKey('spending_category.id'))
company_name = db.Column(db.VARCHAR(255), default="All")
earning_percent = db.Column(db.Float)
active = db.Column(db.BOOLEAN(), default=1)
ulu = db.Column(db.VARCHAR(50))
cards = db.relationship('Card',
backref=db.backref('card_spending_categories',
cascade='all, delete-orphan'))
spending_categories = db.relationship('SpendingCategory',
backref=db.backref(
'spending_category_cards',
cascade='all, delete-orphan'))
class Passenger(db.Model):
"""
拼车的用户
"""
__tablename__ = "passengers"
# 主键
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 发起拼车的童鞋
uid = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
# 拼车信息id
carpool_id = db.Column(db.Integer,
db.ForeignKey("carpools.id"),
nullable=False)
# join time
join_time = db.Column(db.TIMESTAMP, default=None)
# 自己的联系方式(用json方式存储)
contact = db.Column(db.VARCHAR(200), nullable=True)
def __repr__(self):
return "<Passenger uid:{} contact:{}".format(self.uid, self.contact)
class Login(db.Model):
__tablename__ = 'login'
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
username = db.Column(db.VARCHAR(50), unique=True)
password = db.Column(db.VARCHAR(50), unique=True)
business_owner = db.relationship('BusinessRegistration',
backref='owner',
lazy='dynamic')
def __init__(self, username, password):
#self.id= id
self.username = username
self.password = password
class owns(db.Model):
__tablename__ = 'owns'
ownership_id = db.Column(db.Integer, primary_key=True, nullable=False)
customer_id = db.Column(db.Integer,
db.ForeignKey('customer.id'),
nullable=False)
car_vin = db.Column(db.VARCHAR(16), db.ForeignKey('car.vin'))
class Genre(Base):
__tablename__ = 'genre'
id = db.Column(db.Integer, primary_key=True)
genre_name = db.Column(db.String(250), nullable=False)
description = db.Column(db.String, nullable=True)
genre_image = db.Column(db.VARCHAR(200), nullable=True)
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'id': self.id,
'name': self.genre_name,
'description': self.description,
'image': self.genre_image,
}
# New instance instantiation procedure
def __init__(self, genre_name, description, genre_image):
self.genre_name = genre_name
self.description = description
self.genre_image = genre_image
def __repr__(self):
return '<Genre %r>' % (self.genre_name)
class Artist(Base):
__tablename__ = 'artist'
id = db.Column(db.Integer, primary_key=True)
artist_name = db.Column(db.String(250), nullable=False)
genre_id = db.Column(db.Integer, ForeignKey('genre.id'), nullable=True)
genre = db.relationship(Genre)
artist_image = db.Column(db.VARCHAR(200), nullable=True)
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'name': self.artist_name,
'id': self.id,
'genre_id': self.genre_id,
'image': self.artist_image,
}
# New instance instantiation procedure
def __init__(self, artist_name, genre_id):
self.artist_name = artist_name
self.genre_id = genre_id
self.artist_image = artist_image
def __repr__(self):
return '<Artist %r>' % (self.artist_name)
