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)
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')
@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(db.Model, UserMixin):
#req
user_id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(25), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
tc_check = db.Column(db.Boolean, nullable=False)
#times
tl = db.Column(db.DateTime(), default=datetime.utcnow)
last_login = db.Column(db.DateTime(),
default=datetime.utcnow,
onupdate=datetime.utcnow)
#other
visit_count = db.Column(db.Integer, default=0)
about = db.Column(db.VARCHAR(),
default="Welcome to my Profile and Fileshare!")
posted_count = db.Column(db.Integer, default=0)
total_downloads = db.Column(db.Integer, default=0)
#photo
user_photo = db.Column(db.String(255))
priv_key = db.Column(db.Text())
posted = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.user_id}','{self.username}','{self.email}','{self.last_login}','{self.created}')"
##UserMixin
##requires a method that can uniquely identify a user
def get_id(self):
return (self.user_id)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True)
email = db.Column(db.String(128))
password_hash = db.Column(db.String(128), nullable=False)
#the one for one to many
role_id = db.Column(db.Integer, db.ForeignKey('role.id'), nullable=False)
#the many for many to many
posts = db.relationship('Post_User', back_populates='writer')
@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 get_id(self):
return self.username
def __repr__(self):
return '<User %r>' % self.username
class Images(db.Model):
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.String(30), nullable=False)
thumbnail = db.Column(db.String(30), nullable=False)
file_size = db.Column(db.String(30), nullable=False)
file_width = db.Column(db.String(30), nullable=False)
file_height = db.Column(db.String(30), nullable=False)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(60), unique=True, nullable=False)
email = db.Column(db.String(60), unique=True, nullable=False)
password = db.Column(db.String(40), nullable=False)
def __repr__(self):
return 'User(%s,%s)' % (self.username, self.email)
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)
img_file = db.Column(db.String(20), nullable=False, default='default.jpg')
password = db.Column(db.String(60), nullable=False)
post = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.img_file}')"
class Post(db.Model):
post_id = db.Column(db.Integer,
primary_key=True,
unique=True,
nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
nullable=False)
post_filename = db.Column(db.String(25), nullable=False)
title = db.Column(db.String(15), nullable=False)
desc_short = db.Column(db.String(75), nullable=False)
desc_long = db.Column(db.Text, nullable=False)
game_name = db.Column(db.String(15), nullable=False)
game_filetype = db.Column(db.String(15), nullable=False)
game_map = db.Column(db.String(15), nullable=False)
rating = db.Column(db.Integer, nullable=False)
image_primary = db.Column(db.String(25), nullable=False)
image_others = db.Column(db.String(25), nullable=True)
posted_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
private = db.Column(db.Boolean, nullable=False, default=True)
child_file = db.Column(db.Integer, nullable=True)
download_count = db.Column(db.String(25), nullable=False)
search_tags = db.Column(db.String, nullable=False)
def __repr__(self):
return f"Post('{self.post_id}','{self.title}','{self.posted_date}')"
class User(db.Model,UserMixin):
id = db.Column(db.Integer, primary_key=True)
name=db.Column(db.String(60),nullable=False,unique=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email=db.Column(db.String(140),nullable=False,unique=True)
password = db.Column(db.String(60), nullable=False)
location=db.Column(db.String(64))
about_me=db.Column(db.Text())
def __repr__(self):
return 'User(%s,%s,%s)' %(self.name,self.email,self.password)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), nullable=False, unique=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(140), nullable=False, unique=True)
password = db.Column(db.String(60), nullable=False)
location = db.Column(db.String(64))
about_me = db.Column(db.Text())
date_joined = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
post = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return 'User(%s,%s,%s)' % (self.name, self.email, self.password)
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 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)
category = db.Column(db.String(20), nullable=False)
image_path = db.Column(db.String(120), nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
comments = db.relationship('Comment', backref='ref_post', lazy=True)
likes = db.relationship('PostLike', backref='post', lazy='dynamic')
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
def num_likes(self):
return self.likes.count()
class Article(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(32))
description = db.Column(db.Text)
content = db.Column(db.Text)
time = db.Column(db.Date)
click = db.Column(db.Integer, default=0)
recommend = db.Column(db.Integer) #1推荐，0不推荐
picture = db.Column(db.String(32))
author = db.Column(db.String(32), db.ForeignKey("author.id"))
types = db.relationship(
"Type", #外键对那个表
secondary=registration, #关系表是哪个
backref=db.backref("article", lazy="dynamic"), #关系维持
lazy="dynamic" #删除关系
)
comment = db.relationship("Comment", backref="article")
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 f"Post('{self.title}', '{self.date_posted}')"
return "jhjhjhj"
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)
comments = db.relationship('Comment', backref='entry', lazy=True)
def __repr__(self):
return f"User('{self.title}','{self.date_posted}')"
class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
rolename = db.Column(db.String(20))
permissions = db.relationship('Permission',
secondary=permissions,
lazy='subquery',
backref=db.backref('role', lazy=True))
users = db.relationship('User', backref='role')
def __repr__(self):
return '<Role %r>' % self.rolename
class FileContents(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(300))
data = db.Column(db.LargeBinary)
date_uploaded = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"FileContents('{self.name}','{self.user_id}')"
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(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
posts = db.relationship('Post', backref='author', 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)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
profile_image = db.Column(db.String(20),
nullable=False,
default='default.jpg')
email = db.Column(db.String(64), unique=True, index=True)
username = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
posts = relationship('BlogPost', backref='')
def __init__(self, email, username, password):
self.email = email
self.username = username
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return f"Username is {self.username}"
class Author(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32))
age = db.Column(db.String(32))
gender = db.String(db.String(32))
email = db.Column(db.String(32))
photo = db.Column(db.String(32))
article = db.relationship("Article", backref="author")
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)
comments = db.relationship('Comment', backref="author",lazy=True)
# Reset token for password reset e-mail
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
#If user try to verify reset in given time which is expires_sec try block will work otherwise except block will be processed
@staticmethod
def verify_reset_token(token):
s = Serializer(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 BlogPost(db.Model):
users = db.relationship(User)
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
title = db.Column(db.String(140), nullable=False)
text = db.Column(db.Text, nullable=False)
def __init__(self, title, text, user_id):
self.title = title
self.text = text
self.user_id = user_id
def __repr__(self):
return f"Post Date : {self.date}------Post ID : {self.id}--------Title : {self.title}"
class Post(db.Model, BasePost):
id = db.Column(db.Integer, primary_key=True)
writers = db.relationship('Post_User', back_populates='post')
#i can think that the property tilte is defined
title = db.Column(db.String(256), nullable=False)
@property
def first_writer(self):
for writer in self.writers:
if writer.is_first_author:
return writer
return None
@property
def other_writers(self):
_writers = []
for writer in self.writers:
if writer is not True:
_writers.append(writer)
return writer
def __repr__(self):
return '<Post %r>' % self.title
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
comtent = db.Column(db.Text)
time = db.Column(db.DateTime)
persion = db.Column(db.String(32))
article = db.Column(db.Integer, db.ForeignKey("article.id"))
class Type(db.Model):
id = db.Column(db.Integer, primary_key=True)
lable = db.Column(db.String(32))
description = db.Column(db.Text)
article = db.relationship("Article", backref="type")
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(60), unique=True)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_path = db.Column(db.String(120),
nullable=False,
default="default.jpg")
password = db.Column(db.String(80), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
comments = db.relationship('Comment', backref='author', lazy=True)
liked = db.relationship('PostLike',
foreign_keys='PostLike.user_id',
backref='user',
lazy='dynamic')
uploader = db.relationship('FileContents', backref='author', lazy=True)
followed = db.relationship('Following',
foreign_keys="Following.user_id",
backref='user',
lazy='dynamic')
follows = db.relationship('Following',
foreign_keys="Following.following_id",
backref='follows',
lazy='dynamic')
def like_post(self, post):
if not self.has_liked_post(post):
like = PostLike(user_id=self.id, post_id=post.id)
db.session.add(like)
def unlike_post(self, post):
if self.has_liked_post(post):
PostLike.query.filter_by(user_id=self.id, post_id=post.id).delete()
def has_liked_post(self, post):
return PostLike.query.filter(PostLike.user_id == self.id,
PostLike.post_id == post.id).count() > 0
def follow_user(self, user):
if not self.has_followed_user(user):
follow = Following(user_id=self.id, following_id=user.id)
db.session.add(follow)
def unfollow_user(self, user):
if self.has_followed_user(user):
Following.query.filter_by(user_id=self.id,
following_id=user.id).delete()
def has_followed_user(self, user):
return Following.query.filter(Following.user_id == self.id,
Following.following_id
== user.id).count() > 0
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(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.email}','{self.username}')"
class Permission(db.Model):
id = db.Column(db.Integer, primary_key=True)
permission = db.Column(db.String(20))
