class User(db.Model, UserMixin, CRUDMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True, index=True)
password_hash = db.Column(db.String(128))
cs = db.relationship('CS', backref='user', lazy=True, cascade="all,delete")
rating = db.relationship('Rating',
backref='user',
lazy=True,
cascade="all,delete")
def __repr__(self):
return '<User %r>' % self.username
@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)
class User(db.Model, UserMixin):
"""用户"""
__tablename__ = 'user' #对应mysql数据库表
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
pwd = db.Column(db.String(64))
def __init__(self, name, pwd):
self.name = name
self.pwd = pwd
def get_id(self):
return str(self.id)
def __repr__(self):
return '<User %r>' % self.name
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
minister = db.Column(db.String(50))
title = db.Column(db.String(100), nullable=False)
tag = db.Column(db.String(100))
date = db.Column(db.DateTime, default=datetime.utcnow)
message = db.Column(db.Text, nullable=False)
audio = db.Column(db.String(100))
def __str__(self):
return f"Message('{self.minister}', '{self.title}')"
@classmethod
def find_by_title(cls, title: str):
return cls.query.filter_by(title=title).first()
@classmethod
def find_by_id(cls, id: int):
return cls.query.filter_by(id=id).first()
@classmethod
def find_by_minister(cls, minister: str):
return cls.query.filter_by(minister=minister).first()
def save_to_database(self) -> None:
db.session.add(self)
db.session.commit()
def remove_from_database(self) -> None:
db.session.delete(self)
db.session.commit()
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
# generating the password reseting roken
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
# verify the token if the token has exprired or invalid
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(32))
second_name = db.Column(db.String(32))
email = db.Column(db.String(32), index=True, unique=True)
password_hash = db.Column(db.String(128))
def __repr__(self):
return '<User {}>'.format(self.first_name)
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)
roles = relationship(
"Role",
secondary=user_role_rel,
back_populates="users",
)
student_teams = relationship(
"Team",
secondary=team_student_rel,
back_populates="students",
)
mentor_teams = relationship(
"Team",
secondary=team_mentor_rel,
back_populates="mentors",
)
class Employee(UserMixin, db.Model):
_tablename_ = 'employees'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(60), index=True, unique=True)
username = db.Column(db.String(60), index=True, unique=True)
first_name = db.Column(db.String(60), index=True)
last_name = db.Column(db.String(60), index=True)
password_hash = db.Column(db.String(128))
department_id = db.Column(db.Integer, db.ForeignKey('departments.id'))
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
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 '<Employee: {}>'.format(self.username)
class DatasetManager(db.Model):
__tablename__ = "DatasetManager"
id = db.Column(db.Integer, primary_key=True)
datasetName = db.Column(db.String(255), unique=True, nullable=False)
datasetSqlName = db.Column(db.String(255), unique=True, nullable=False)
comment = db.Column(db.String(255), nullable=True)
createDateTime = db.Column(db.DateTime, nullable=True, default=datetime.utcnow)
class ResearchInfo(db.Model):
__tablename__ = "ResearchInfo"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
weblink = db.Column(db.String(500))
description = db.Column(db.Text, nullable=True)
tags = db.Column(db.String(500))
createDateTime = db.Column(db.DateTime, nullable=True, default=datetime.utcnow)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
def __repr__(self):
return f"User('{self.username}', '{self.email}')"
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
def __repr__(self):
return '<User {}>'.format(self.username)
class TestLog(db.Model):
__tablename__ = "TestLog"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), unique=True, nullable=True)
value = db.Column(db.String(255), nullable=True)
createDateTime = db.Column(db.DateTime,
nullable=True,
default=datetime.utcnow)
class Papers(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(400), index=True)
url = db.Column(db.String(200), index=True)
doi = db.Column(db.String(100), index=True)
proposer_id = db.Column(db.Integer, db.ForeignKey('users.id'))
schedule = db.relationship('Schedules', backref='paper', lazy='dynamic')
def __repr__(self):
return '<Paper {}>'.format(self.title)
class WebContent(db.Model):
__tablename__ = "WebContent"
id = db.Column(db.Integer, primary_key=True)
sectionName = db.Column(db.String(255), nullable=True)
contentName = db.Column(db.String(255), nullable=True)
webContent = db.Column(db.Text, nullable=True)
def __repr__(self):
return (
f"WebContent('{self.sectionName}','{self.contentName}','{self.webContent}')"
)
class Users(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True)
surname = db.Column(db.String(64), index=True)
email = db.Column(db.String(120), index=True, unique=True)
is_admin = db.Column(db.Boolean(), default=False)
paper = db.relationship('Papers', backref='proposer', lazy='dynamic')
schedule = db.relationship('Schedules', backref='speaker', lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.surname)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(50), nullable=False)
def save_to_database(self) -> None:
db.session.add(self)
db.session.commit()
def remove_from_database(self) -> None:
db.session.delete(self)
db.session.commit()
class Contact(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
email = db.Column(db.String(100))
message = db.Column(db.Text)
def save_to_database(self) -> None:
db.session.add(self)
db.session.commit()
def remove_from_database(self) -> None:
db.session.delete(self)
db.session.commit()
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
default='default.jpeg',
nullable=False)
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return "User('%s','%s','%s')" % (self.username, self.email,
self.image_file)
class Role(db.Model):
"""
Create a Role table
"""
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), unique=True)
description = db.Column(db.String(200))
employees = db.relationship('Employee', backref='role', lazy='dynamic')
def __repr__(self):
return '<Role: {}>'.format(self.name)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
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)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
class DeprecatedToken(db.Model):
"""
Token Model for storing JWT tokens
"""
__tablename__ = 'deprecated_tokens'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.String(500), unique=True, nullable=False)
deprecated_on = db.Column(db.DateTime,
nullable=False,
default=datetime.now())
def __init__(self, token):
self.token = token
def __repr__(self):
return '<id: token: {}'.format(self.token)
@staticmethod
def check_deprecated(token):
is_deprecated = DeprecatedToken.query.filter(token=token).first()
if is_deprecated:
return True
else:
return False
class Person(db.Model):
name = db.Column(db.String(20), primary_key=True)
age = db.Column(db.SmallInteger(), default="0", nullable=False)
def __init__(self, name, age):
self.name = name
self.age = age
class Groups(db.Model):
__tablename__ = 'groups'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False, unique=True)
cost_group = db.relationship('CostGroup', backref='cost_group', lazy=True)
def __init__(self, name):
self.name = name
def to_json(self):
json_group = {
'url': url_for('api.get_group', id=self.id, _external=True),
'name': self.name,
'costs': url_for('api.group_costs', id=self.id, _external=True),
'debt_table': url_for('api.debt_table', id=self.id, _external=True)
}
return json_group
@staticmethod
def from_json(group_json):
try:
name = group_json.get('name')
if name is None:
return None
return Groups(name)
except AttributeError:
return None
class Recipe(db.Model):
__tablename__ = 'recipes'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(16), unique=True, nullable=False)
default = db.Column(
db.Boolean
) # initialize this to 1 if you're adding a default meal to the database, custom meals will be 0
ingredients = db.relationship('Ingredient', secondary=ing_rec_assc)
def cumulative_neg_attributes(self):
"""
Total number of negative attributes across all ingredients
"""
count = 0
for ing in self.ingredients:
for att in ing.attributes:
if not att:
count += 1
return count
def cumulative_pos_attributes(self):
"""
Total number of negative attributes across all ingredients
"""
count = 0
for ing in self.ingredients:
for att in ing.attributes:
if att:
count += 1
return count
class Track(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(32))
desc = db.Column(Text())
blocks = relationship("Block",
secondary=track_block_rel,
back_populates="tracks")
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 Announcement(db.Model):
id = db.Column(db.Integer, primary_key=True)
annouce = db.Column(db.String(50))
image = db.Column(db.String(50), default="default.jpg")
content = db.Column(db.Text, nullable=False)
@classmethod
def find_by_id(cls, id: int):
return cls.query.filter_by(id=id).first()
def save_to_database(self) -> None:
db.session.add(self)
db.session.commit()
def remove_from_database(self) -> None:
db.session.delete(self)
db.session.commit()
class Gallery(db.Model):
id = db.Column(db.Integer, primary_key=True)
tag = db.Column(db.String(50), nullable=False)
image = db.Column(db.String(50), default="default.jpg")
org_img = db.Column(db.String(50), default="default.jpg")
date = db.Column(db.DateTime, default=datetime.utcnow)
@classmethod
def find_by_id(cls, id: int):
return cls.query.filter_by(id=id).first()
def save_to_database(self) -> None:
db.session.add(self)
db.session.commit()
def remove_from_database(self) -> None:
db.session.delete(self)
db.session.commit()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
social_id = db.Column(db.String(64), nullable=True, unique=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=True)
registration_date = db.Column(db.DateTime,
nullable=False,
default=datetime.now())
admin = db.Column(db.Boolean, nullable=False, default=False)
def __int__(self, email, password, admin=False):
self.email = email
self.password = bcrypt.generate_password_hash(
password, app.config["BCRYPT_ROUND"]).decode()
self.admin = admin
@staticmethod
def encode_auth_token(user_id):
try:
payload = {
'exp': datetime.now() + timedelta(days=1),
'iat': datetime.now(),
'sub': user_id
}
return jwt.encode(payload=payload,
key=Config.SECRET_KEY,
algorithm='HS256')
except Exception as error:
return error
@staticmethod
def decode_auth_token(auth_token):
try:
payload = jwt.decode(auth_token, Config.SECRET_KEY)
is_deprecated = DeprecatedToken.check_deprecated(auth_token)
if is_deprecated:
return 'Token deprecated. Please log in again.'
else:
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please login again'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class Team(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(32))
students = relationship("User",
secondary=team_student_rel,
back_populates="student_teams")
mentors = relationship("User",
secondary=team_mentor_rel,
back_populates="mentor_teams")
class Service(db.Model):
__tablename__ = 'services'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), index=True, unique=True)
base_url = db.Column(db.String(64), index=True, unique=True)
description = db.Column(db.String(256))
internal = db.Column(db.Boolean, default=True, nullable=False)
@property
def help_url(self):
return self.base_url + "/help"
@property
def demo_url(self):
return self.base_url + "/demo"
@property
def get_params_url(self):
return self.base_url + "/params"
