class User(db.Model, UserMixin):
__tablename__ = "users"
__table_args__ = {"useexisting": True, 'mysql_collate': 'utf8_general_ci'}
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100), unique=True, nullable=False)
email_confirmed = db.Column(db.Boolean, nullable=False)
name = db.Column(db.String(100), nullable=False)
role = db.Column(db.Enum(UserRole), nullable=False)
_password = db.Column(db.String(128), nullable=False)
created_time = db.Column(db.DateTime, default=datetime.now)
@hybrid_property
def password(self):
return self._password
@password.setter
def _set_password(self, plaintext):
self._password = bcrypt.generate_password_hash(plaintext)
def is_correct_password(self, plaintext):
return bcrypt.check_password_hash(self._password, plaintext)
def __repr__(self):
return "<User %r>" % self.name
class Tour(db.Model):
__tablename__ = "tours"
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(255), nullable=False)
artist = db.Column(db.String(255), nullable=False)
description = db.Column(db.Text(), nullable=False)
genre = db.Column(db.String(255), nullable=False)
start_date = db.Column(db.DateTime(), nullable=False)
end_date = db.Column(db.DateTime(), nullable=False)
user_id = db.Column(db.Integer(),
db.ForeignKey("users.id"),
index=True,
nullable=False)
slug = db.Column(db.String(255), nullable=False, unique=True)
def __init__(self, title, artist, description, genre, start_date, end_date,
user_id):
self.title = title
self.artist = artist
self.description = description
self.genre = genre
self.start_date = start_date
self.end_date = end_date
self.user_id = user_id
class Album(db.Model):
__tablename__ = "albums"
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(255), nullable=False)
artist = db.Column(db.String(255), nullable=False)
description = db.Column(db.Text(), nullable=False)
genre = db.Column(db.String(255), nullable=False)
image = db.Column(db.Text(), nullable=False)
release_date = db.Column(db.DateTime(), nullable=False)
user_id = db.Column(db.Integer(),
db.ForeignKey("users.id"),
index=True,
nullable=False)
slug = db.Column(db.String(255), nullable=False, unique=True)
def __init__(self, title, artist, description, genre, image, release_date,
user_id):
self.title = title
self.artist = artist
self.description = description
self.genre = genre
self.image = image
self.release_date = release_date
self.user_id = user_id
class User(db.Model):
uid = db.Column(db.Integer, primary_key=True, autoincrement=True)
uname = db.Column(db.String(16), unique=True)
upassword = db.Column(db.String(256))
def save(self):
db.session.add(self)
db.session.commit()
class Admin(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20))
password_hash = db.Column(db.String(128))
def __repr__(self):
return '用户名：%s' % 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 Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String(30))
email = db.Column(db.String(254))
site = db.Column(db.String(255))
body = db.Column(db.Text)
from_admin = db.Column(db.Boolean, default=False)
reviewed = db.Column(db.Boolean, default=False)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
# post = db.relationship('Post', back_populates='comments')
replied_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
replied = db.relationship('Comment',
back_populates='replies',
remote_side=[id])
replies = db.relationship('Comment',
back_populates='replied',
cascade='all')
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(60))
body = db.Column(db.Text)
body_html = db.Column(db.Text)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', back_populates='posts')
comments = db.relationship('Comment', backref='post', cascade='all')
class Standard(db.Model):
id = db.Column(db.Integer, primary_key=True)
public_id = db.Column(GUID, default=uuid4, unique=True, nullable=False)
type = db.Column(db.String(100), nullable=False)
value = db.Column(db.Float, nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True)
password_hash = db.Column(db.String(150))
emil = db.Column(db.String(50), unique=True)
cinfirmed = db.Column(db.Boolean, default=False)
@property
def password(self):
raise AttributeError('密码不告诉你')
# 加密存储密码
@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):
id = db.Column(db.Integer, primary_key=True)
public_id = db.Column(GUID, default=uuid4, unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(100), nullable=False, unique=True)
status = db.Column(db.Enum(UserStatus),
nullable=False,
default=UserStatus.email_is_not_verified)
name = db.Column(db.String(100), nullable=False, default="Anonymous")
surname = db.Column(db.String(100), nullable=False, default="Anonymous")
group = db.Column(db.String(100), nullable=False, default="Anonymous")
club = db.Column(db.String(100), nullable=False, default="Anonymous")
standards = db.relationship(
'Standard',
lazy='dynamic',
cascade='all,delete',
backref=db.backref('user', lazy='subquery'),
)
def set_password(self, password):
self.password = generate_password_hash(password)
def is_correct_password(self, password):
return check_password_hash(self.password, password)
class Language(db.Model):
__table_args__ = {"schema": "line"}
__tablename__ = 'language'
id = db.Column(db.Integer, primary_key=True)
symbol = db.Column(db.String())
def __init__(self, lang_id, symbol):
self.id = lang_id
self.symbol = symbol
def __repr__(self):
return '<line_id {}: lang_id {}>'.format(self.id, self.symbol)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, nullable=False)
email = db.Column(db.String(64), unique=True, nullable=False, index=True)
password_hash = db.Column(db.String(255), nullable=False)
is_admin = db.Column(db.Boolean(), default=False)
albums = db.relationship('Album',
backref='user',
lazy='dynamic',
cascade='all, delete-orphan')
tours = db.relationship('Tour',
backref='user',
lazy='dynamic',
cascade='all, delete-orphan')
def __init__(self, username='', email='', password=''):
self.username = username
self.email = email
self.password_hash = generate_password_hash(password)
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 is_album_owner(self, album):
return self.id == album.user_id
def is_tour_owner(self, tour):
return self.id == tour.user_id
def make_admin(self):
self.is_admin = True
def __repr__(self):
return f'<User {self.username}>'
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(200), unique=True, nullable=False)
is_active = db.Column(db.Boolean, default=False, nullable=False)
def __repr__(self):
return "<{} {}>".format(self.__class__.__name__, self.username)
def save(self):
db.session.add(self)
db.session.commit()
return self
def to_dict(self):
d = {}
for c in self.__table__.columns:
d[c.name] = str(getattr(self, c.name))
return d
class LineUser(db.Model):
__table_args__ = {"schema": "line"}
__tablename__ = 'line_user'
line_id = db.Column(db.String(), primary_key=True)
lang_id = db.Column(db.Integer,
db.ForeignKey('line.language.id'),
default=1)
image_command_id = db.Column(db.Integer,
db.ForeignKey('line.image_command.id'),
default=1)
def __init__(self, line_id, lang_id):
self.line_id = line_id
self.lang_id = lang_id
def __repr__(self):
return '<line_id {}: lang_id {}>'.format(self.line_id, self.lang_id)
class UserModel(CrudMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String, nullable=False)
last_name = db.Column(db.String)
email = db.Column(db.String, unique=True, nullable=False)
_password = db.Column('password', db.String(120))
set_password_token = db.Column(db.String, unique=True)
set_password_token_expiry = db.Column(db.DateTime)
@property
def password(self):
return self._password
@password.setter
def password(self, password):
self._password = generate_password_hash(password)
def check_password(self, password):
if self.password is None:
return False
return check_password_hash(self.password, password)
@staticmethod
def get_user_by_token(token):
return UserModel.query.filter(UserModel.set_password_token == token
).first() if token is not None else None
@staticmethod
def get_user_by_emails(emails):
return UserModel.query.filter(UserModel.email.in_(emails)).all()
@staticmethod
def get_user_by_ids(ids):
return UserModel.query.filter(UserModel.id.in_(ids)).all()
class ImageCommand(db.Model):
__table_args__ = {"schema": "line"}
__tablename__ = 'image_command'
id = db.Column(db.Integer, db.Sequence('image_command'), primary_key=True)
command = db.Column(db.String(), unique=True, nullable=False)
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True)
posts = db.relationship('Post', back_populates='category')
class Bloginfo(db.Model):
id = db.Column(db.Integer, primary_key=True)
blog_title = db.Column(db.String(60))
blog_sub_title = db.Column(db.String(100))
name = db.Column(db.String(30), default='浩楠')
about = db.Column(db.Text)
