class User(db.Model, UserMixin): # 表名将会是 user（自动生成，小写处理）
email = db.Column(db.String(50), primary_key=True) # 邮箱, 主键
password_hash = db.Column(db.String(128)) # 密码哈希
# confirmed = db.Column(db.Boolean, default=False)
# def generate_confirmation_token(self, expiration=3600):
# s = Serializer(app.config['SECRET_KEY'], expiration)
# return s.dumps({'confirm': self.email})
# @staticmethod
# def check_activate_token(self, token):
# s = Serializer(app.config['SECRET_KEY'])
# try:
# data = s.loads(token) # 解码
# except Exception:
# return False
# user = User.query.get(email=data.get('confirm'))
# if user is None:
# return False
# if not user.confirmed:
# user.confirmed = True
# db.session.add(user)
# return True
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
def get_id(self):
return self.email
class Movie(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(60))
year = db.Column(db.String(4))
def __repr__(self):
return '<Movie {}>'.format(self.title)
class Message(db.Model):
__tablename__ = 'Message'
id = db.Column(db.Integer, primary_key=True) # id（主键）
course_name = db.Column(db.String(50), db.ForeignKey('Course.name')) # 消息对应的课程
title = db.Column(db.String(50)) # 消息的标题
info = db.Column(db.String(1000)) # 消息的内容
class User(db.Model, UserMixin): # 表名将会是 user（自动生成，小写处理）
id = db.Column(db.Integer, primary_key=True) # 主键
name = db.Column(db.String(20))
username = db.Column(db.String(20)) # 用户名
password_hash = db.Column(db.String(300)) # 密码散列值
def set_password(self, password): # 用来设置密码的方法，接受密码作为参数
self.password_hash = generate_password_hash(password) # 将生成的密码保持到对应字段
def validate_password(self, password): # 用于验证密码的方法，接受密码作为参数
return check_password_hash(self.password_hash, password) # 返回布尔值
def set_name(self, name):
self.name = name
def set_username(self, username):
self.username = username
def valid_username(self, username):
valid_length = 0 < len(username) and len(username) <= 20
ret = valid_length and username.isalnum() # 内置函数，判断字符串是否只含字母和数字
return ret
def valid_password(self, password):
valid_length = 0 < len(password) and len(password) <= 20
ret = valid_length and password.isalnum() # 判断字符串是否为字母和数字组合
return ret
class User(db.Model, UserMixin):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
username = db.Column(db.String(20))
password_hash = db.Column(db.String(128))
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return str(self.id) # python 3
def __repr__(self):
return '<User %r>' % self.nickname
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class Comment(db.Model):
__tablename__ = "comments"
__table_args__ = {'mysql_charset': 'utf8mb4'} # 支持表情emoji
id_comment = db.Column(db.Integer,
primary_key=True,
nullable=False,
unique=True)
# 外键, 删除用户/文章 同时删去对应的评论
id_user = db.Column(db.Integer, ForeignKey('users.id'))
author = relationship("User",
backref=backref(
"Comment",
cascade='save-update, delete, delete-orphan'),
cascade='save-update',
single_parent=True)
# user = relationship("User", back_populates="comments",
# cascade='save-update, delete, delete-orphan')
id_article = db.Column(db.Integer, ForeignKey('articles.id_article'))
article = relationship("Article",
backref=backref(
"Comment",
cascade='save-update, delete, delete-orphan'),
cascade='save-update',
single_parent=True)
# article = relationship("Article", back_populates="comments",
# cascade='save-update, delete, delete-orphan')
content = db.Column(db.String(200), nullable=False, comment="评论内容")
create_time = db.Column(db.DateTime, default=func.now(), comment="创建评论时间")
class Article_Has_Tag(db.Model):
__tablename__ = "article_has_tags"
# 外键， 删除文章/标签 同时删除本表关联内容
id_article = db.Column(db.Integer,
ForeignKey("articles.id_article"),
primary_key=True)
id_tag = db.Column(db.Integer, ForeignKey("tags.id_tag"), primary_key=True)
# 引用文章 删除, 孤儿模式(被父表接触关系 自己也删除了)
article = relationship("Article",
backref=backref("article_has_tags", cascade="all"),
cascade='save-update',
single_parent=True)
# 引用标签对象
tag = relationship("Tag",
backref=backref(
'article_has_tags',
cascade='save-update, delete, delete-orphan'),
cascade='save-update',
single_parent=True)
# article.tag.append(Tag(), Tag())
# def __init__(self, tag=None, article=None):
# self.article = article
# self.tag = tag
def __repr__(self):
return f"Article({self.id_article})-Tag({self.id_tag})"
class GPU(db.Model):
__tablename__ = 'GPU'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50)) # gpu的名称
info = db.Column(db.String(1000)) # gpu是否空闲
course_name = db.Column(db.String(50),
db.ForeignKey('Course.name')) # gpu对应的课程
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
username = db.Column(db.String(20)) # 用户名
password_hash = db.Column(db.String(128)) # 密码散列值
def set_password(self, password): # 用来设置密码的方法，接受密码作为参数
self.password_hash = generate_password_hash(password) # 将生成的密码保持到对应字段
def validate_password(self, password): # 用于验证密码的方法，接受密码作为参数
return check_password_hash(self.password_hash, password) # 返回布尔值
class Movie(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
year = db.Column(db.String(4))
def __repr__(self):
return '<Movie(id={}, title={}, year={})>'.format(
self.id, self.title, self.year
)
class Ariticles(db.Model):
id = db.Column(db.Integer, primary_key=True) # 主键
title = db.Column(db.String(60))
content = db.Column(db.Text, nullable=False)
author_id = db.Column(db.Integer,
db.ForeignKey(User.id),
default=1,
nullable=False)
pubdate = db.Column(db.DateTime, default=datetime.now, nullable=False)
class Article(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(32))
content = db.Column(db.Text, nullable=False)
tag = db.Column(db.String(64), nullable=True)
create_time = db.Column(db.DateTime, nullable=True, default=datetime.now)
def __repr__(self):
return '<User %r>' % self.title
class Ariticles(db.Model):
id = db.Column(db.Integer, primary_key=True) # 主键
title = db.Column(db.String(50)) #标题
content = db.Column(db.Text) #内容
author = db.Column(db.String(20)) #作者
pubdate = db.Column(
db.String(30),
index=True,
default=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) #发布时间
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
username = db.Column(db.String(20))
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin): # 表名将会是 user（自动生成，小写处理）
id = db.Column(db.Integer, primary_key=True) # 主键
name = db.Column(db.String(20)) # 名字
username = db.Column(db.String(20)) # 用户名
password_hash = db.Column(db.String(128)) # 密码散列值
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin): # 表名将会是 user（自动生成，小写处理）
id = db.Column(db.Integer, primary_key=True) # 主键
name = db.Column(db.String(20)) # 名字
username = db.Column(db.String(20)) # 用户名
password_hash = db.Column(db.String(128)) # 密码散列值
def set_password(self, password): # 设置密码方法，接受密码作为参数
self.password_hash = generate_password_hash(password) # 将生成的密码保存到对应的字段
def validate_password(self, password): # 用于验证密码的方法，接受密码作为参数
return check_password_hash(self.password_hash, password) # 返回布尔值
class User(db.Model, UserMixin): # user模型，继承db.Model而来，表名为user（小写，自动生成）
id = db.Column(db.Integer, primary_key=True) # 每一个字段要实例化db.Column，传入字段类型
name = db.Column(db.String(20))
user_name = db.Column(db.String(20)) # 用户名
password_hash = db.Column(db.String(128)) # 密码散列值
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20))
password_hash = db.Column(db.String(128))
movies = db.relationship('Movie', backref='user')
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin):
__tablename__ = "wl_user" # 数据库表名，未定义则默认是类名
id = db.Column(db.Integer, primary_key=True) # flask中主键必须显示定义，自增长类型
name = db.Column(db.String(20))
username = db.Column(db.String(20))
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin): #模型类，数据库表的对象关系映射。
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
username = db.Column(db.String(20))
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = generate_password_hash(
password) #将密码进行hash加密后保存变量
def validate_password(self, password) -> bool:
return check_password_hash(self.password_hash, password) #返回bool值
class User(db.Model, UserMixin):
"""docstring for ClassName"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
username = db.Column(db.String(20))
password_hash = db.Column(db.String(128)) # 密码散列
def set_password(self, password): # 设置密码方法，接收密码作为参数
self.password_hash = generate_password_hash(password)
def validate_password(self, password): # 验证密码方法， 接收密码作为参数
return check_password_hash(self.password_hash, password) # 返回布尔值
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True, nullable=True)
name = db.Column(db.String(20)) # 昵称
username = db.Column(db.String(20)) # 用户名
password_hash = db.Column(db.String(128)) # 密码散列值
articles = db.relationship("Articles", backref="user") # 连接博文信息表
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin): # 数据库表，表名为user
id = db.Column(db.Integer, primary_key=True) # 主键，个人理解应该是序号
name = db.Column(db.String(20)) # 名字
username = db.Column(db.String(20)) # 用户名
password_hash = db.Column(db.String(128)) # 密码散列值
def set_password(self, password):
"""用来生成密码的散列值"""
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
"""验证输入密码与散列值是否一致"""
return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin): # 表名将会是user（自动生成，小写处理）
id = db.Column(db.Integer, primary_key=True) # 主键
name = db.Column(db.String(20)) # 名字
username = db.Column(db.String(20)) #用户名
password_hash = db.Column(db.String(128)) # 密码Hash值
def set_password(self, password):
# 用来设置密码到方法，接受密码作为参数，将生成到密码保持到对应字段
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
# 用于验证密码到方法，接受密码作为参数，返回布尔值
return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
username = db.Column(db.String(50))
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return '<User(id={}, name={})>'.format(self.id, self.name)
class User(db.Model, UserMixin):
"""表名自动生成，为user, id与name分别为主键名与列名"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
username = db.Column(db.String(20)) # 用户名
password_hash = db.Column(db.String(128)) # 密码hash值
def set_password(self, password):
"""生成密码散列值，参数为密码"""
self.password_hash = generate_password_hash(password)
def validate_password(self, password):
"""验证密码, 密码为参数"""
return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin): #用户认证用到 UserMixin
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
username = db.Column(db.String(20)) # 用户名
email = db.Column(db.String(20))
password_hash = db.Column(db.String(128)) #密码散列值
# tall = db.Column(db.Integer)
# nickname = db.Column(db.String(20))
#生成密码散列值
def set_password(self, password):
self.password_hash = generate_password_hash(password)
#核对散列值与密码是否匹配
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
class User(UserMixin, db.Model):
"""用户模型"""
id = db.Column(db.INTEGER, primary_key=True)
name = db.Column(db.String(32)) # 名字
password_hash = db.Column(db.String(128))
@property
def password(self):
"""不能直接访问密码"""
raise AttributeError("不允许读取当前属性")
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def check_password(self, password) -> bool:
"""校验密码"""
return check_password_hash(self.password_hash, password)
class Course(db.Model):
__tablename__ = 'Course'
id = db.Column(db.Integer, primary_key=True) # id（主键）
name = db.Column(db.String(50)) # 课程名称
teacher = db.Column(db.String(50)) # 任课老师
time = db.Column(db.String(50)) # 授课时间（学年、学期）
info = db.Column(db.String(300)) # 课程其他信息
course_name = db.Column(db.String(50), db.ForeignKey('Course.name')) # 用户对应的课程
gpu_name = db.Column(db.String(50), db.ForeignKey('GPU.name')) # gpu name
pic_path = db.Column(db.String(128), default="/static/pic/course_logo.png") # 课程头像
class Process(db.Model):
__tablename__ = 'Process'
id = db.Column(db.Integer, primary_key=True) # id（主键）
name = db.Column(db.String(50)) # 程序的名称
info = db.Column(db.String(300)) # 程序的信息
state = db.Column(db.String(50)) # 是否运行完成
result = db.Column(db.String(1000)) # 程序的结果
code = db.Column(db.String(10000)) # 存储代码，方便以后编辑代码
course_name = db.Column(db.String(50), db.ForeignKey('Course.name')) # 程序所属的课程
gpu_name = db.Column(db.String(50), db.ForeignKey('GPU.name')) # 程序在哪个gpu上跑的
