class Base(db.Model):
__abstract__ = True
id = db.Column(db.String(36), default=uuid_str, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
class Users(db.Model):
""""""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column("username", db.String(64))
display_name = db.Column("DisplayName", db.String(128))
email = db.Column("Email", db.String(128))
# spotify_username = db.Column("spotify_username", db.String(64))
# saved_tracks_id = db.Column(db.Integer, db.ForeignKey("saved_tracks.id"))
# saved_tracks = db.relationship("SavedTracks", backref="users")
# top_artists_id = db.Column(db.Integer, db.ForeignKey("top_artists.id"))
top_artists = db.relationship("TopArtists", backref="users")
# top_tracks_id = db.Column(db.Integer, db.ForeignKey("top_tracks.id"))
top_tracks = db.relationship("TopTracks", backref="users")
# user_playlists_id = db.Column(db.Integer, db.ForeignKey("UserPlaylists.id"))
# user_playlists = db.relationship(
# UserPlaylists, uselist=False, back_populates="users"
# )
# followed_artists_id = db.Column(db.Integer, db.ForeignKey("followed_artists.id"))
# followed_artists = db.relationship("FollowedArtists", backref="users")
def get_user_id(self):
return self.id
def get_username(self):
return self.username
class Preview(db.Model):
__tablename__='preview'
id=db.Column(db.Integer,primary_key=True)
title=db.Column(db.String(255),unique=True)
logo=db.Column(db.String(255),unique=True)
addtime=db.Column(db.DATETIME,index=True,default=datetime.datetime.now)
def __repr__(self):
return "preview %s"%self.title
def preview_add(data):
try:
db.session.add(data)
db.session.commit()
return True
except Exception as e:
print(e)
return False
def preview_edit(id,data):
try:
preview=Preview.query.filter_by(id=id).first_or_404()
preview.id=data.id
preview.title=data.title
preview.logo=data.logo
db.session.add(preview)
db.session.commit()
return True
except Exception as e:
return False
def preview_del(id):
preview=Preview.query.filter_by(id=id).first_or_404()
db.session.delete(preview)
db.session.commit()
return True
class Teacher(UserMixin, db.Model):
__tablename__ = 'teachers'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
password_hash = db.Column(db.String(128))
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def __init__(self, id, name, password=app.config['DEFAULT_PASSWD']):
self.id = id
self.name = name
self.password_hash = password
@staticmethod
def add_teacher1():
th1 = Teacher(1234567891, u'李老师')
db.session.add(th1)
db.session.commit()
def __repr__(self):
return '<Teacher %r>' % self.id
class Booking(db.Model):
__tablename__ = 'booking'
id = db.Column(db.Integer, primary_key=True)
is_cancel = db.Column(db.Boolean, default=False)
cancelation_reason = db.Column(db.String(200))
booked_datetime = db.Column(db.DateTime, default=datetime.now())
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
total_price = db.Column(db.Integer)
client_id = db.Column(db.Integer, db.ForeignKey('client.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
activated = db.Column(db.Boolean, default=False)
booked_services = db.relationship('Service', secondary=service_booked)
provided_services = db.relationship('Service', secondary=service_provided)
def fill_booked_services(self, id_list):
"""fills booked_services by given service ids """
for id in id_list:
s = Service.query.get(id)
self.booked_services.append(s)
def fill_provided_services(self, id_list):
"""fills provided_services by given service ids """
for id in id_list:
s = Service.query.get(id)
self.provided_services.append(s)
class PaticipatorInfo(db.Model):
__tablename__ = 'paticipator_info'
id = db.Column(db.Integer, primary_key=True)
activity_id = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# 报名时间
timestamp = db.Column(db.DateTime, default=datetime.datetime.now)
class Location(db.Model):
__tablename__ = 'location'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.uid'))
name = db.Column(db.String(100))
address = db.Column(db.String(200))
city = db.Column(db.String(50))
state = db.Column(db.String(50))
#country=db.column(db.String(50))
zip = db.Column(db.String(20))
lat = db.Column(db.Float)
lng = db.Column(db.Float)
is_end_point = db.Column(db.Integer, unique=False, default=0)
def __init__(self, user_id, name, address, city, state, zip, lat, lng,
is_end_point):
self.user_id = user_id
self.name = name
self.address = address
self.city = city
self.state = state
#self.country=country
self.zip = zip
self.lat = lat
self.lng = lng
self.is_end_point = is_end_point
class Participant(UserMixin, db.Model):
"""create a Participant table"""
__tablename__ = 'participants'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), )
email = db.Column(db.String(60), unique=True)
password_hash = db.Column(db.String(128))
is_admin = db.Column(db.Boolean, default=False)
@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_hash = generate_password_hash(password)
def verify_password(self, password):
"""
Check if hashed password matches actual password
"""
return check_password_hash(self.password_hash, password)
def __repr__(self):
return '<Participant: {}>'.format(self.name)
class Tag(db.Model):
__tablename__='tag'
id=db.Column(db.Integer,primary_key=True)
name=db.Column(db.String(100),unique=True)
addtime=db.Column(db.DATETIME,index=True,default=datetime.datetime.now)
# movies=db.relationship('Movie',backref='tag')
movies=db.Column(db.Integer)
def __repr__(self):
return "<tag %s>"%self.name
def tag_add(name):
try:
tag=Tag(
name=name,
)
db.session.add(tag)
db.session.commit()
return True
except Exception as e:
return False
def tag_del(id):
tag=Tag.query.filter_by(id=id).first_or_404()
db.session.delete(tag)
db.session.commit()
return True
def tag_edit(id,name):
tag=Tag.query.filter_by(id=id).first_or_404()
db.session.delete(tag)
db.session.commit()
tag=Tag(
id=id,
name=name
)
db.session.add(tag)
db.session.commit()
return True
class Comments(db.Model):
__tablename__ = 'comments'
postId = db.Column(db.Integer)
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(500))
email = db.Column(db.String(100))
body = db.Column(db.String(5000))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True)
password_hash = db.Column(db.String(64))
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
def generate_auth_token(self, expiration=600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.query.get(data['id'])
return user
class WarehouseSuppliers(db.Model):
__tablename_ = "warehouse_suppliers"
supplier_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
supplier_Creation_date = db.Column(db.DateTime,
default=datetime.datetime.today,
nullable=False)
supplier_name = db.Column(db.VARCHAR(60), nullable=False)
class Role(db.Model):
role_id = db.Column(db.String(7), primary_key=True)
role_name = db.Column(db.String(255), nullable=False)
user = db.relationship('User', backref='role', lazy=True)
def __repr__(self) -> str:
return '<Role %s>' % self.role_name
class Role(db.Model):
"""
Roles are an aggregate of permissions
"""
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(64), unique=True)
description = db.Column(db.String(280))
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
def __repr__(self):
return '<Role: {}> \n'.format(self.name)
@staticmethod
def insert_roles():
roles = {
'Customer': (Permission.BUY, True),
'Moderator': (Permission.BUY |
Permission.WRITE_BLOGS |
Permission.MODERATE_CONTENT, False),
'Administrator': (0xff, False)
}
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.permissions = roles[r][0]
role.default = roles[r][1]
db.session.add(role)
db.session.commit()
class Student(UserMixin, db.Model):
__tablename__ = 'students'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode)
Class = db.Column(db.Unicode)
password_hash = db.Column(db.String(128))
grades = db.relationship('Grade', backref='student', lazy='dynamic')
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
def __init__(self, id, name, Class, password=app.config['DEFAULT_PASSWD']):
self.id = id
self.name = name
self.Class = Class
self.password_hash = password
@staticmethod
def add_stu1():
stu1 = Student(1234567890, 'stu1', 123)
db.session.add(stu1)
db.session.commit()
def __repr__(self):
return '<Student %r>' % self.id
class BackUp(db.Model):
__tablename__ = 'back_up'
id = db.Column(db.Integer, primary_key=True)
job_id = db.Column(db.Integer)
file_name = db.Column(db.String(50))
is_done = db.Column(db.Boolean, default=False)
timestamp = db.Column(db.DateTime, index=True)
class Photos(db.Model):
__tablename__ = 'photos'
albumId = db.Column(db.Integer)
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200))
url = db.Column(db.String(300))
thumbnailUrl = db.Column(db.String(300))
class BucketListItem(BaseModel):
"""
Class used as a representation of the bucketlist item model
"""
name = db.Column(db.Text, nullable=False)
finished_by = db.Column(
db.Date, default=datetime.now(tz=pytz.timezone('Africa/Kampala')))
bucketlist_id = db.Column(db.Integer,
db.ForeignKey('bucket_list.id'),
nullable=False)
def add_bucketlist_item(self):
"""
Method is used to add a bucketlist item to the database
"""
self.add_data_set()
return True
def delete_bucketlist_item(self):
"""
Method is used to add a bucketlist item to the database
"""
self.delete_data_set()
db.session.commit()
return True
class Users(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String, unique=False, nullable=False)
lastname = db.Column(db.String, unique=False, nullable=False)
address = db.Column(db.String, unique=False, nullable=False)
phone = db.Column(db.String, unique=True, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
username = db.Column(db.String, unique=True, nullable=False)
password = db.Column(db.String, nullable=False)
verified = db.Column(db.BOOLEAN, nullable=False, default=False)
admin = db.Column(db.BOOLEAN, nullable=False, default=False)
def __init__(self,
firstname,
lastname,
address,
phone,
email,
username,
password,
verified,
admin=False):
self.firstname = firstname
self.lastname = lastname
self.address = address
self.phone = phone
self.email = email
self.username = username
self.password = generate_password_hash(password)
self.verified = verified
self.admin = admin
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True)
location = db.Column(db.String(64))
password_hash = db.Column(db.String(128))
def __repr__(self):
return '<User {}>'.format(self.name)
class News(db.Model):
id = db.Column(db.Integer, primary_key=True)
news_title = db.Column(db.String(255), nullable=False)
news_message = db.Column(db.String(255), nullable=False)
news_file = db.Column(db.String(255), nullable=True)
def __repr__(self) -> str:
return '<Role %s>' % self.news_title
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post %r>' % self.body
class Book(db.Model):
__tablename__ = 'book'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(40), nullable=False)
author = db.Column(db.String(60), nullable=False)
publish_date = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class UserInfo(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), nullable=False)
created = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
def __repr__(self):
return 'id: {}, username: {}, created: {}'.format(
self.id, self.username, self.created)
class Module(db.Model):
__tablename__ = "modules"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
courses = db.relationship("Course")
def to_json(self):
return {"id": self.id, "name": self.name}
class Scores(db.Model):
__tablename__ = "scores"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
score = db.Column(db.Integer)
course_id = db.Column(db.Integer, db.ForeignKey("courses.id"))
user = db.relationship("User")
course = db.relationship("Course")
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post {}>'.format(self.body)
class Resource(db.Model):
ip = db.Column(db.String, primary_key=True)
username = db.Column(db.String(30), unique=True, nullable=False)
password = db.Column(db.String(30), nullable=False)
availability = db.Column(db.Boolean, nullable=False, default=True)
def __repr__(self):
return f"Resource('{self.ip}', '{self.username}', '{self.password}')"
class Player(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True, nullable=False)
platform = db.Column(db.String(3), nullable=False)
def __repr__(self):
return ("Username : {} Platform : {}".format(self.username,
self.platform))
class User(Base):
__tablename__ = 'user'
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(8), nullable=False)
def __init__(self, email, password):
self.email = email
self.password = password