class User(flask_login.UserMixin, db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(32), unique=True)
email = db.Column(db.String(128), unique=True)
profile_pic_path = db.Column(db.String(), default="Fake -- Dont touch me")
pp_path = db.Column(db.String(256), default='/static/uploads/default.png')
password_hash = db.Column(db.String(256))
last_seen = db.Column(db.DateTime(), default=datetime.datetime.now())
posts = db.relationship('Post', backref="author")
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 has_posts(self):
return len(self.posts) > 0
def follows(self, user_id):
user = self.followed.filter_by(id=user_id).first()
if not user: return False
return True
def __repr__(self):
return "<User {}>".format(self.name)
class User(UserMixin, db.Model):
"""Model to store blog's user related information."""
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(32), nullable=False, unique=True)
password_hash = db.Column(db.String(256), nullable=False)
posts = db.relationship("Post", backref="user")
comments = db.relationship("Comment", backref="user")
liked_posts = db.relationship("Post",
secondary=likes,
backref="liked_by",
lazy="dynamic")
saved_posts = db.relationship(
"Post",
secondary=saves,
backref="saved_by",
lazy="dynamic",
)
def set_password(self, password):
"""Create hashed password."""
self.password_hash = generate_password_hash(password, method="sha256")
def check_password(self, password):
"""Check hashed password."""
return check_password_hash(self.password_hash, password)
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(128), nullable=False)
body = db.Column(db.Text)
created_at = db.Column(db.DateTime, server_default=db.func.now())
updated_at = db.Column(db.DateTime,
server_default=db.func.now(),
server_onupdate=db.func.now())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
comments = db.relationship('Comment', backref='belong_to_post', lazy=True)
add_category = db.relationship('Category',
secondary=post_category,
lazy='subquery',
backref=db.backref('list_post', lazy=True))
def __init__(self, title, body, user_id):
self.title = title
self.body = body
self.user_id = user_id
def __repr__(self):
return (f'This post has title {self.title}')
class AddProduct(db.Model):
id=db.Column(db.Integer,primary_key=True)
name=db.Column(db.String(80),nullable=False)
price=db.Column(db.Integer,nullable=False)
discount=db.Column(db.Integer,default=0)
stock=db.Column(db.Integer,nullable=False)
desc=db.Column(db.Text,nullable=False)
brand_id=db.Column(db.Integer,db.ForeignKey('brand.id'))
brand=db.relationship('Brand',backref=db.backref('brands',lazy=True))
category_id=db.Column(db.Integer,db.ForeignKey('category.id'))
category=db.relationship('Category',backref=db.backref('categories',lazy=True))
buy_id=db.Column(db.Integer,db.ForeignKey('buy.id'))
buy=db.relationship('Buy',backref=db.backref('buys',lazy=True))
colors=db.Column(db.String(80),nullable=False)
date=db.Column(db.DateTime,nullable=False,default=datetime.utcnow)
image1=db.Column(db.String(150),nullable=False,default='image.jpg')
image2=db.Column(db.String(150),nullable=False,default='image.jpg')
image3=db.Column(db.String(150),nullable=False,default='image.jpg')
def __repr__(self):
return f"AddProduct('{self.name}','{self.price}')"
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100))
email = db.Column(db.String(255), unique=True, index=True, nullable=False)
bio = db.Column(db.String(255))
profile_pic_path = db.Column(db.String())
password_hash = db.Column(db.String(255))
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
blogs = db.relationship('Blog', backref='user', lazy='dynamic')
comments = db.relationship('Comment', backref='user', lazy='dynamic')
@property
def password(self):
raise AttributeError('You cannot read the password attritube')
@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 __repr__(self):
return f'User {self.username}'
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), nullable=False, unique=True)
email = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(500), nullable=False)
firstname = db.Column(db.String(50), default='Firstname')
lastname = db.Column(db.String(50), default='Lastname')
city = db.Column(db.String(50), default='Moscow')
birthdate = db.Column(db.String(50), nullable=True, default='1990-01-01')
gender = db.Column(db.String(50), default='Male')
is_confirmed = db.Column(db.Boolean, nullable=False, default=False)
registration_date = db.Column(db.DateTime, nullable=True)
userpic = db.Column(db.String(30), default='default.jpg')
followers_qty = db.Column(db.Integer, default=0)
posts = db.relationship('Post',
backref='user',
cascade="all, delete",
lazy='dynamic')
likes = db.relationship('Like',
backref='user',
cascade="all, delete",
lazy='dynamic')
@staticmethod
def ensure_unique_username(name):
"""Ensure user name does not already exist"""
if User.query.filter_by(name=name).first() is None:
return name
version = 1
while True:
old_name = name
new_name = name + '_' + str(version)
if User.query.filter_by(name=new_name).first() is None:
break
version += 1
# flash('Your name has been changed to {} as user {} already exists.'.format(new_name, old_name), 'success')
return new_name
def __str__(self):
return 'User {}'.format(self.username)
def all_users():
return User.query.all()
def get_user_by_username(username):
return User.query.filter_by(username=username).first()
def all_followers(id):
return User.query.join(
followers,
(User.id == followers.c.follower_id)).filter_by(user_id=id).all()
def all_followed_by_user(id):
return User.query.join(
followers,
(User.id == followers.c.user_id)).filter_by(follower_id=id).all()
class User(flask_login.UserMixin, db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(32))
password_hash = db.Column(db.String(256))
last_seen = db.Column(db.DateTime(), default=datetime.datetime.now())
posts = db.relationship('Post', backref="author")
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 has_posts(self):
return len(self.posts) > 0
def follows(self, user_id):
user = self.followed.filter_by(id=user_id).first()
print("user id: {} {}".format(user_id, type(user_id)))
print("Followed ids")
for follower in self.followed:
print(follower.id, type(follower.id))
if not user:
print("I am false")
return False
print("I am True")
return True
def __repr__(self):
return "<User {}>".format(self.name)
class Article(db.Model):
__tablename__ = 'article'
__bind_key__ = 'blog2'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
body = db.Column(db.Text)
description = db.Column(db.String(500))
body_html = db.Column(db.Text)
visited = db.Column(db.Integer, default=0)
photo = db.Column(db.String(100))
create_date = db.Column(db.DateTime, default=datetime.now)
create_user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
catalog_id = db.Column(db.Integer, db.ForeignKey('catalog.id'))
recommand = db.Column(db.String(1))
hidden = db.Column(db.Integer)
order_id = db.Column(db.Integer, default=0)
create_user = db.relationship('User',
backref='create_user',
foreign_keys=create_user_id)
catalogs = db.relationship('Catalog',
backref='catalogs',
foreign_keys=catalog_id)
tags = db.relationship('Tag', secondary=articles_tags, backref='tags')
def __repr__(self):
return '<Article %r>' % self.title
@staticmethod
def on_body_changed(target, value, oldvalue, initiator):
if value is None or value == '':
target.body_html = ''
else:
target.body_html = markdown(value)
class Users(UserMixin, db.Model):
userId = db.Column(db.Integer, primary_key=True)
firstName = db.Column(db.String(40), nullable=False)
lastName = db.Column(db.String(40), nullable=False)
email = db.Column(db.String(255), nullable=False, unique=True)
userName = db.Column(db.String(40), nullable=False, unique=True)
passwordHash = db.Column(db.String(128), nullable=False)
comment = db.relationship('Comments', backref='user', lazy=True)
ratings = db.relationship('Ratings', backref='user', lazy=True)
taggings = db.relationship('Taggings', backref='user', lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}')"
def get_id(self):
return self.userId
@property
def password(self):
raise AttributeError('password is not a readable attribute')
@password.setter
def password(self, password):
self.passwordHash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.passwordHash, password)
@login_manager.user_loader
def load_user(user_id):
return Users.query.get(int(user_id))
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(15), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password_hash = db.Column(db.String(128))
password = db.Column(db.String(60), nullable=False)
post = db.relationship('Post', backref='user', lazy=True)
comment=db.relationship('Comment',backref='user',lazy=True)
like=db.relationship('Like',backref='user',lazy=True)
tag=db.relationship('Tag',backref='user',lazy=True)
first_name = db.Column(db.String(80))
last_name = db.Column(db.String(80))
mobile_phone = db.Column(db.String(11))
is_admin = db.Column(db.Boolean, nullable=False, default=False)
def __repr__(self):
return f"User('{self.username}', '{self.email}')"
@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(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True)
email = db.Column(db.String(64), unique=True, nullable=False)
password_hash = db.Column(db.String(256))
favorite = db.relationship('Post',
secondary=user_favorite_post,
lazy='subquery',
backref=db.backref('list_favorite_user',
lazy=True))
posts = db.relationship('Post', backref='author', lazy='dynamic')
comments = db.relationship('Comment', backref='author', lazy=True)
def __init__(self, email):
self.email = email
def is_already_favorite(self, post_id):
return post_id in self.favorite
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 User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
access_level = db.Column(db.Integer)
username = db.Column(db.String(64), index=True, unique=True)
password = db.Column(db.String(128))
fullname = db.Column(db.String(128), index=True)
email = db.Column(db.String(120), index=True, unique=True)
phone_number = db.Column(db.String(10), index=True, unique=True)
homeworks = db.relationship("HomeWork", backref="author", lazy="dynamic")
solutions = db.relationship("Solution", backref="author", lazy="dynamic")
messages_sent = db.relationship("Message",
foreign_keys="Message.sender_id",
backref="author",
lazy="dynamic")
messages_received = db.relationship("Message",
foreign_keys="Message.recipent_id",
backref="recipient",
lazy="dynamic")
last_message_read_time = db.Column(db.DateTime)
def __repr__(self):
return "<User {}>".format(self.username)
def check_password(self, password):
return self.password == password
def is_teacher(self):
return self.access_level == 1
def new_messages(self):
last_read_time = self.last_message_read_time or datetime(1900, 1, 1)
return Message.query.filter_by(recipient=self).filter(
Message.timestamp > last_read_time).count()
class Segue(db.Model):
__tablename__ = "segue"
id = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer, ForeignKey('usuarios.id'))
id_seguidor = db.Column(db.Integer, ForeignKey('usuarios.id'))
usuario = db.relationship('Usuario', foreign_keys=id_usuario)
seguidor = db.relationship('Usuario', foreign_keys=id_seguidor)
class Comment(db.Model, CRUDMixin, Serializer):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(1000))
body_html = db.Column(db.Text)
timestamp = db.Column(db.DateTime, default=lambda: datetime.utcnow())
disabled = db.Column(db.Boolean, default=False)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'))
replied = db.relationship('Reply',
foreign_keys=[Reply.reply_id],
backref=db.backref('replies', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
replies = db.relationship('Reply',
foreign_keys=[Reply.replied_id],
backref=db.backref('replied', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
def __repr__(self):
return str(self.json()).replace(',', '\n')
def reply(self, comment):
reply = Reply(replies=self, replied=comment)
db.session.add(reply)
db.session.commit()
@staticmethod
def on_change_body(target, value, oldvalue, initiator):
allowed_tags = [
'a', 'abbr', 'acronym', 'b', 'code', 'em', 'i', 'blockquote'
'strong', 'ol', 'li', 'ul', 'p', 'span', 'img', 'pre', 's'
]
allowed_styles = ['background-color']
allowed_attributes = {
'a': ['href', 'title'],
'abbr': ['title'],
'acronym': ['title'],
'pre': ['class', 'spellcheck']
}
target.body_html = bleach.linkify(
bleach.clean(markdown(value, output_format='html'),
tags=allowed_tags,
strip=True,
styles=allowed_styles,
attributes=allowed_attributes))
def to_json(self):
json_data = {
'body_html': self.body_html,
'timestamp': self.timestamp.strftime('%Y-%m-%d %H:%M:%S'),
'author': self.author.username,
'avatar': self.author.avatar,
'uid': self.author_id,
'id': self.id
}
return json_data
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
replies = db.relationship('Reply', backref='writer', lazy=True)
def __repr__(self):
return f"Username: {self.username}, Email: {self.email}"
class Post(db.Model):
id = db.Column(db.Integer, primary_key = True)
title = db.Column(db.String(200), nullable = False)
content = db.Column(db.Text, nullable = False)
date_posted = db.Column(db.DateTime, nullable = False, default = datetime.utcnow)
photos = db.relationship('Photo', backref = 'post', lazy = "dynamic")
comments = db.relationship('Comments', backref = 'post', lazy = True)
def __repr__(self):
return f"Post('{self.id}','{self.title}','{self.date_posted}')"
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='user', lazy=True)
comments = db.relationship('Comment', backref='user', lazy=True)
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='commenter', lazy=True)
def __repr__(self):
return f"User {self.username}, {self.email}"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
title = db.Column(db.Text, nullable=False)
content = db.Column(db.Text, nullable=False)
image_file = db.Column(db.String(40), nullable=False, default='default.jpg')
author_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
likes=db.Column(db.Integer, nullable=False, default=0)
comment=db.relationship('Comment',backref='post',lazy=True)
like=db.relationship('Like',backref='post',lazy=True)
tag=db.relationship('Tag',backref='post',lazy=True)
def __repr__(self):
return f"Post('{self.date}', '{self.title}', '{self.content}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_posted = db.Column(db.DateTime(),
nullable=False,
default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
pokemons = db.relationship('Pokemon', backref='post', lazy='dynamic')
wins = db.Column(db.Integer, default=0)
loses = db.Column(db.Integer, default=0)
likes = db.relationship('PostLike', backref='post', lazy='dynamic')
comments = db.relationship('Comment', backref='post', lazy='dynamic')
def __repr__(self):
return f"Post('{self.pokemons}', '{self.date_posted}', '{self.likes.count()}')"
class Comment(db.Model):
""""""
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.ForeignKey(User.uid), nullable=False)
parent = db.Column(db.ForeignKey(Post.id), nullable=False)
comment = db.Column(db.TEXT(8388608), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
post_author = db.relationship(User, lazy="joined", backref="comments")
parent_post = db.relationship(Post, lazy="joined", backref="comments")
def __repr__(self):
return "<Comment {0}> <User {1}>".format(self.id, self.author_id)
class Author(db.Model):
__tablename__ = 'author'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(120), unique=True)
passwd = db.Column(db.String(120))
article = db.relationship('Article', backref='author', lazy='dynamic')
def __init__(self, name, passwd):
self.name = name
self.passwd = passwd
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
def get_id(self):
return unicode(self.id)
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(100), unique=True, nullable=False)
imageFile = db.Column(db.String(20), nullable=False, default="default.jpg")
password = db.Column(db.String(60), nullable=False)
#Here, posts references the Post class. Backref creats an attribute on a Post object
#accessed by doing Post.author
posts = db.relationship("Post", backref="author", lazy=True)
def get_reset_token(self, expireSeconds=1800):
serializer = Serializer(current_app.config['SECRET_KEY'],
expireSeconds)
return serializer.dumps({"userID": self.id}).decode("utf-8")
@staticmethod
def verify_reset_token(token):
serializer = Serializer(current_app.config['SECRET_KEY'])
try:
userID = serializer.loads(token)['userID']
except:
return None
return User.query.get(userID)
#User is represented as User(Username, Email, ProfileImageFile)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.imageFile}')"
class User(db.Model,UserMixin):
id=db.Column(db.Integer,primary_key=True)
username=db.Column(db.String(15),unique=True,nullable=False)
password=db.Column(db.String(100),nullable=False)
email=db.Column(db.String(50),unique=True,nullable=False)
information=db.Column(db.String(100))
twitter=db.Column(db.String(30))
Linkedin=db.Column(db.String(50))
image=db.Column(db.String(100),nullable=False,default="default.jpg")
instagram=db.Column(db.String(30))
posts=db.relationship("Post",backref="author",lazy=True)
def get_reset_token(self,expires_sec=3600):
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"username:{self.username},id:{self.id}")
class Post(db.Model):
"""
A post on the blog
:key slug: Slug of this post (KEY)
:key date: Date of this post
:key title: Title of this post
:key lead: The first two sentences of the post for display on selection pages
:key body_md: Markdown version of this post
:key body_html: HTML version of this post (generated automatically from markdown)
:key css_file: Optional name of the custom css file (optional)
:key js_file: Optional name of the custom css file (optional)
:key user_shortname: Shortname of the user who posted this
:key user: User who posted this
:key tags: Tags for this post
"""
slug = db.Column(db.String, primary_key=True)
date = db.Column(db.Date, default=date.today())
title = db.Column(db.String)
lead = db.Column(db.Text)
body_md = db.Column(db.Text)
body_html = db.Column(db.Text)
css_file = db.Column(db.String, default=None, nullable=True)
js_file = db.Column(db.String, default=None, nullable=True)
user_shortname = db.Column(db.String, db.ForeignKey('user.shortname'))
tags = db.relationship('Tag', secondary=tags, backref=db.backref('posts'))
def __str__(self):
"""
Return a string representation of the object
:return: :rtype: str
"""
return self.title
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) # hashing creates a 60 character string
posts = db.relationship(
'Post', backref='author', lazy=True
) # backref creates and allows us to use "author" attribute in Post
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 # not to expect a self argument
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 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.png')
password = db.Column(db.String(60), nullable=False)
# relationship between User and Post model
posts = db.relationship('Post', backref='author', lazy=True)
# expires in 30 minutes
def get_reset_token(self, expires_sec=1800):
# generates time-sensitive token
s = Serializer(app.config['SECRET_KEY'], expires_sec)
# returns the token for the specific id
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_set_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.load(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):
user_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 = 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(app.config["SECRET_KEY"], expires_in=expires_sec)
return s.dumps({"user_id": self.get_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 Exception:
return None
return User.query.get(user_id)
def get_id(self):
return self.user_id
def __repr__(self):
return f"User({self.username}, {self.email}, {self.image})"
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.png')
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):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(40), nullable=False)
email = db.Column(db.String(40), nullable=False)
first_name = db.Column(db.String(40), nullable=False)
last_name = db.Column(db.String(40), nullable=False)
password_hash = db.Column(db.String(255), nullable=False)
is_active = db.Column(db.Boolean(), default=True, nullable=False)
is_superuser = db.Column(db.Boolean(), default=False, nullable=False)
date_joined = db.Column(db.DateTime(timezone=True),
server_default=func.now())
blogs = db.relationship("Blog", backref="user")
def __init__(self, username, email, first_name, last_name, password):
self.username = username
self.email = email
self.first_name = first_name
self.last_name = last_name
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def __repr__(self):
return f'{self.first_name} {self.last_name}'
