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 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(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 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 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 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(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 User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('admin', lazy='dynamic'))
class User(db.Model,UserMixin):
id=db.Column(db.Integer,primary_key=True)
username=db.Column(db.String(20),unique=True)
email=db.Column(db.String(120),unique=True,nullable=False)
image=db.Column(db.String(20),nullable=False,default='zero.jpg')
password=db.Column(db.String(60),nullable=False)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users,backref=db.backref('users', lazy='dynamic'))
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)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
name = db.Column(db.String(255))
second_name = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
class Article(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User',
backref=db.backref('articles', lazy='dynamic'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category',
backref=db.backref('articles', lazy='dynamic'))
timestamp = db.Column(db.DateTime, nullable=False)
update_date = db.Column(db.DateTime)
def __init__(self, title, content, user_id, category_id):
self.title = title
self.content = content
self.user_id = user_id
self.category_id = category_id
self.timestamp = datetime.now()
self.update_date = datetime.now()
def create_article(self):
db.session.add(self)
db.session.commit()
return "Article added successfully"
@staticmethod
def get_articles():
articles = Article.query.all()
return articles
@staticmethod
def get_article(article_id):
article = Article.query.filter_by(id=article_id).first()
return article
@staticmethod
def get_user_articles(user_id):
user_articles = Article.query.filter_by(user_id=user_id).all()
return user_articles
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(20), nullable=False)
lastname = db.Column(db.String(20), nullable=False)
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)
is_admin = db.Column(
db.Boolean, nullable=False, default=False
) #admins are special so they get a separate block to the rest of the columns
post = db.relationship('Post', backref='user', lazy=True)
comment = db.relationship('Comment', backref='user', lazy=True)
favourites = db.relationship('Post',
secondary=favs,
backref=db.backref('followers',
lazy='dynamic'))
liked = db.relationship('Post',
secondary=likes,
backref=db.backref('likers', lazy='dynamic'))
def __repr__(self):
return f"User('{self.username}', '{self.email}')"
#making sure we cant accidentall read peoples passwords becuase security
@property
def password(self):
raise AttributeError('password is not a readable attribute')
#setting the password
@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 Comment(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=False)
email = db.Column(db.String(120), unique=False, nullable=False)
message = db.Column(db.Text, nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
post = db.relationship('Post', backref=db.backref('post', lazy=True))
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
status = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<User %r>' % self.username
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
body = db.Column(db.Text, nullable=False)
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('posts', lazy=True))
def __repr__(self):
return '<Post %r>' % self.title
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), unique=True, nullable=False)
feature = db.Column(db.Boolean, default=False)
description = db.Column(db.String(150), nullable=False)
body = db.Column(db.Text, unique=False, nullable=False)
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.now())
owner = db.Column(db.Integer(), db.ForeignKey('user.id'))
tags = db.relationship('Tag',
secondary=tags,
backref=db.backref('posts', lazy='dynamic'))
def __repr__(self):
return '<Post %r>' % self.title
class Posts(db.Model, DbBase):
posts_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 文件原来的名字
filename = db.Column(db.String(128), nullable=False)
# 文件的存储地址
last_modify_time = db.Column(db.BigInteger, index=True)
content = db.Column(db.String(15000))
# 关联变量
tags = db.relationship('Tag', secondary='posts_tag', backref=db.backref('posts_set'))
# 添加配置设置编码
__table_args__ = {
'mysql_charset': 'utf8'
}
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=False, nullable=False)
email = db.Column(db.String(120), unique=False, nullable=False)
message = db.Column(db.Text, nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
post = db.relationship('Post', backref=db.backref('post', lazy=True))
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
status = db.Column(db.Boolean, default=False)
def __repr__(self):
return f"User('{self.name}', '{self.message}')"
class Book(db.Model):
id=db.Column(db.Integer,primary_key=True)
name=db.Column(db.String(80),nullable=False)
page=db.Column(db.String(80),nullable=False)
price=db.Column(db.Integer,nullable=False)
much=db.Column(db.Integer,nullable=False)
jold=db.Column(db.Integer,nullable=False,default=0)
desc=db.Column(db.Text,nullable=False)
category_id=db.Column(db.Integer,db.ForeignKey('category.id'))
category=db.relationship('Category',backref=db.backref('categories',lazy=True))
date=db.Column(db.DateTime,nullable=False,default=datetime.utcnow)
image1=db.Column(db.String(150),nullable=False,default='image.jpg')
def __repr__(self):
return f"Book('{self.name}','{self.price}')"
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)
likers = db.relationship("Like", foreign_keys=[Like.liked_post], backref=db.backref("post", lazy="joined"), lazy="dynamic", cascade="all, delete-orphan")
def __repr__(self):
return f"Post('{self.date}', '{self.title}', '{self.content}')"
def is_liked_by(self, user):
if user.id is None:
return False
return self.likers.filter_by(liker_id=user.id).first() is not None
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(128), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(160))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
followed = db.relationship('User',
secondary=followed_followers,
primaryjoin=(followed_followers.c.follower_id == id),
secondaryjoin=(followed_followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return f'User {self.username} - {self.email}'
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 get_avatar(self, size):
avatar = md5(self.email.lower().encode('utf-8')).hexdigest()
return f'https://www.gravatar.com/avatar/{avatar}?d=identicon&s={size}'
def is_following(self, user):
return self.followed.filter(followed_followers.c.followed_id == user.id).first()
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def get_followed_posts(self):
followed = Post.query.\
join(followed_followers, (followed_followers.c.followed_id == Post.user_id)).\
filter(followed_followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120), nullable=False)
content = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, nullable=False, default=datetime.now)
tags = db.relationship('Tag',
secondary=tags,
lazy='subquery',
backref=db.backref('posts', lazy=True))
cat_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
comments = db.relationship('Comment', backref='post', lazy=True)
views = db.Column(db.Integer, default=0)
def __repr__(self):
return f"Post({self.id}, '{self.title}')"
class Comment(db.Model):
"""评论"""
__tablename__ = "comment" # 表名
id = db.Column(db.Integer, primary_key=True) # 评论id 主键
content = db.Column(db.Text, nullable=False) # 评论内容 不允许为空
article_id = db.Column(db.Integer, db.ForeignKey("article.id")) # 评论文章的id 外键
parent_id = db.Column(db.Integer, db.ForeignKey("comment.id")) # 父评论id 自关联外键
nick_name = db.Column(db.String(64), nullable=False) # 用户名，不允许为空
email = db.Column(db.String(48), nullable=True) # 邮箱
url = db.Column(db.String(48), nullable=True, default="#") # 网址
reply_name = db.Column(db.String(64)) # 被回复人id
create_time = db.Column(db.DateTime, default=datetime.now) # 创建时间
parent = db.relationship("Comment", remote_side=[id],
backref=db.backref('childs', lazy='dynamic'))
def __repr__(self):
return self.content
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(15), unique=True, nullable=False)
firstname = db.Column(db.String(120), unique=False, nullable=False)
lastname = db.Column(db.String(120), unique=False, 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)
liked = db.relationship("Like", foreign_keys=[Like.liker_id], backref=db.backref("user", lazy="joined"), lazy="dynamic", cascade="all, delete-orphan")
is_admin = db.Column(db.Boolean, nullable=False, default=False)
def __repr__(self):
return f"User('{self.username}', '{self.firstname}', '{self.lastname}', '{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)
def like(self, post):
if not self.is_liking(post):
likes = Like(liker_id=self.id, liked_post=post.id)
db.session.add(likes)
def unlike(self, post):
likes = self.liked.filter_by(liked_post=post.id).first()
if likes:
db.session.delete(likes)
def is_liking(self, post):
if Post.id is None:
return False
return self.liked.filter_by(liked_post=post.id).first() is not None
class Entry(db.Model):
__tablename__ = 'entry'
STATUS_PUBLIC = 0
STATUS_DRAFT = 1
STATUS_DELETED = 2
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
slug = db.Column(db.String(100), unique=True)
body = db.Column(db.Text)
status = db.Column(db.SmallInteger, default=STATUS_PUBLIC)
created_timestamp = db.Column(db.DateTime,
default=datetime.datetime.now) # 第一次保存更新
modified_timestamp = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now) #每次保存更新
author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
tags = db.relationship('Tag',
secondary=entry_tags,
backref=db.backref('entries', lazy='dynamic'))
# Tag 表示查询的模型，entry_tags表示查询的表，backref反向查询，lazy表示不需要加载所有的entry对象，只需要加载查询的对象即可
def __init__(self, *args, **kwargs):
super(Entry, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
self.slug = ''
if self.title:
self.slug = slugify(self.title)
@property
def tag_list(self):
return ', '.join(tag.name for tag in self.tags)
@property
def tease(self):
return self.body[:100]
def __repr__(self):
return '<Entry: %s>' % self.title
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(140))
slug = db.Column(db.String(140), unique=True)
body = db.Column(db.Text)
created = db.Column(db.DateTime, default=datetime.now())
tags = db.relationship('Tag',
secondary=post_tags,
backref=db.backref('posts', lazy='dynamic'))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.title:
self.slug = slugify(self.title)
def __repr__(self):
return f'<Post id: {self.id}, title: {self.title}>'
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(180), nullable=False)
slug = db.Column(db.String(180), nullable=False)
body = db.Column(db.Text, nullable=False)
comments = db.Column(db.Integer, default=0)
view = db.Column(db.Integer, default=0)
image = db.Column(db.String(120), default='image.jpg')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
author = db.relationship('User', backref=db.backref('authors', lazy=True))
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
return '<Post %r>' % self.title
#for make format url
@staticmethod
def generat_slug(target, value, oldvalue, initiator):
if value and (not target.slug or value != oldvalue):
target.slug = slugify(value)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True, index=True)
email = db.Column(db.String(30), unique=True, index=True)
password = db.Column(db.String(200))
avatar = db.Column(db.String(100), default='default.png')
posts = db.relationship('Post', backref='author', lazy=True)
comments = db.relationship('Comment', backref='author', lazy=True)
recomments = db.relationship('ReComment', backref='author', lazy=True)
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
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 __repr__(self):
return "user id:{}, username:{}, email:{}".format(
self.id, self.username, self.email)
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 __repr__(self):
return "<User {}>".format(self.name)
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)
liker = db.relationship('Post', secondary=likes, backref=db.backref('liked_posts', lazy='dynamic'))
def has_liked(self, post): # returns True is the user has liked some post
return db.session.query(likes).filter(likes.c.user_liked == self.id, likes.c.post_liked == post.id).count() > 0
def like(self, post):
if not self.has_liked(post):
self.liker.append(post)
def unlike(self, post):
if self.has_liked(post):
self.liker.remove(post)
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(50), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
post = db.relationship('Post',
backref=db.backref('author', lazy='joined'),
lazy='select')
#function to initialize reset passwords
def reset_token(self):
s = Serializer(app.config['SECRET_KEY'], 1800)
return s.dumps({'user_id': self.id}).decode('utf-8')
#def __init__(self, username , email , password ):
#self.reset_token = reset_token()
#self.username = username
#self.email = email
#self.password = password
@staticmethod
def verify_token(token): #verifying 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}, {self.post}")'
