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 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 WhoOwesWhom(db.Model):
id = db.Column(db.Integer, primary_key=True)
who = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
whom = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
group_id = db.Column(db.Integer,
db.ForeignKey('groups.id'),
nullable=False)
debt_amount = db.Column(db.Integer)
def __init__(self, who, whom, group_id):
self.who = who
self.whom = whom
self.group_id = group_id
self.debt_amount = 0
@property
def get_amount(self):
return self.debt_amount
def plus_amount(self, amount):
self.debt_amount += amount
def to_json(self):
json_wow = {
'who': url_for('api.get_user', id=self.who, _external=True),
'whom': url_for('api.get_user', id=self.whom, _external=True),
'group': url_for('api.get_group', id=self.group_id,
_external=True),
'debt_amount': self.debt_amount
}
return json_wow
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 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 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 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 CostGroup(db.Model):
__tablename__ = 'cost_groups'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
group_id = db.Column(db.Integer,
db.ForeignKey('groups.id'),
nullable=False)
group_member = db.relationship('User', backref='group', lazy=True)
def __init__(self, user_id, group_id):
self.user_id = user_id
self.group_id = group_id
def to_json(self):
json_memberships = {'user_id': self.user_id, 'group_id': self.group_id}
return json_memberships
@staticmethod
def from_json(memberships_json):
try:
user_id = memberships_json.get('user_id')
group_id = memberships_json.get('group_id')
if user_id is None or group_id is None:
return None
return CostGroup(user_id, group_id)
except AttributeError:
return None
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 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 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 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 Association(db.Model, CRUDMixin):
employee = db.Column(db.Integer,
db.ForeignKey('archive_employees.id',
ondelete='cascade'),
primary_key=True)
rating = db.Column(db.Integer,
db.ForeignKey('ratings.id', ondelete='cascade'),
primary_key=True)
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 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 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 UserRoles(db.Model):
__tablename__ = "user_roles"
id = db.Column(db.Integer(), primary_key=True)
# Define foreign keys with Users and Role tables
user_id = db.Column(db.Integer(),
db.ForeignKey("users.id", ondelete="CASCADE"))
role_id = db.Column(db.Integer(),
db.ForeignKey("roles.id", ondelete="CASCADE"))
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 Client(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), index=True)
request = db.relationship('Request', backref='client', lazy='dynamic')
# def __repr__(self):
# return '<Client %r>' % (self.name)
def __repr__(self):
return f"<Client(name='{self.name}')>"
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 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 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 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 Texts(db.Model):
id = db.Column(db.Integer, primary_key=True)
from_username = db.Column(db.String, nullable=False)
to_username = db.Column(db.String, nullable=False)
text = db.Column(db.String, nullable=False)
time = db.Column(db.DateTime, nullable=False, default=datetime.now)
def __init__(self, from_username, to_username, text):
self.from_username = from_username
self.to_username = to_username
self.text = text
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return "Post('%s','%s')" % (self.title, self.date_posted)
class Contest(db.Model):
LANGS = [
(u'python', u'Python'),
]
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(32))
desc = db.Column(Text())
unit_test = db.Column(Text())
lang = db.Column(ChoiceType(LANGS))
blocks = relationship("Block",
secondary=contest_block_rel,
back_populates="contests")
class Food_Group(db.Model):
"""
Class which accesses the DB table for food groups
"""
__tablename__ = 'food_groups'
fg_id = db.Column(db.Integer, primary_key=True) # Unique ID, autoincrement, primary key
fg_name = db.Column(db.String(12), unique=True, nullable=False) # Name of the food group, must be unique (there should only ever be 5)
ingredients = db.relationship('Ingredient', backref='fg') # Notate DB relationship b/w ingredients and food group
def __repr__(self):
return self.fg_name # What is printed when the class is queried (required)
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 Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
def __init__(self, **kwargs):
super(Role, self).__init__(**kwargs)
if self.permissions is None:
self.permissions = 0
@staticmethod
def insert_roles():
roles = {
'User': [Permission.COST, Permission.WRITE],
'Moderator':
[Permission.COST, Permission.WRITE, Permission.MODERATE],
'Administrator': [
Permission.COST, Permission.WRITE, Permission.MODERATE,
Permission.ADMIN
],
}
default_role = 'User'
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.reset_permissions()
for perm in roles[r]:
role.add_permission(perm)
role.default = (role.name == default_role)
db.session.add(role)
db.session.commit()
def add_permission(self, perm):
if not self.has_permission(perm):
self.permissions += perm
def remove_permission(self, perm):
if self.has_permission(perm):
self.permissions -= perm
def reset_permissions(self):
self.permissions = 0
def has_permission(self, perm):
return self.permissions & perm == perm
def __repr__(self):
return '<Role %r>' % self.name
