class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
author = db.relationship(User, backref=db.backref('comments', lazy=True))
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
post = db.relationship(
Post,
backref=db.backref(
'comments',
order_by='Comment.date_posted.desc()',
lazy=True,
# the following line enables deleting automatically
# the comments of a post when deleting the post
# uncomment to activate it
# cascade="all, delete-orphan"
))
def __repr__(self):
return f"<Comment(id='{self.id}', post_id='{self.post_id}', user_id='{self.user_id}', date_posted='{self.date_posted}')>"
class Addproduct(db.Model):
__seachbale__ = ['name', 'desc']
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
price = db.Column(db.Numeric(10, 2), nullable=False)
discount = db.Column(db.Integer, default=0)
stock = db.Column(db.Integer, nullable=False)
colors = db.Column(db.Text, nullable=False)
desc = 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('categories', lazy=True))
brand_id = db.Column(db.Integer, db.ForeignKey('brand.id'), nullable=False)
brand = db.relationship('Brand', backref=db.backref('brands', lazy=True))
image_1 = db.Column(db.String(150), nullable=False, default='image1.jpg')
image_2 = db.Column(db.String(150), nullable=False, default='image2.jpg')
image_3 = db.Column(db.String(150), nullable=False, default='image3.jpg')
def __repr__(self):
return '<Post %r>' % self.name
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
usertags = db.relationship('User',
secondary='tagmapper',
backref=db.backref('usertags', lazy='dynamic'))
notetags = db.relationship('Note',
secondary='notemapper',
backref=db.backref('notetags', lazy='dynamic'))
def __repr__(self):
return f"Post('{self.id}', '{self.name}')"
class Account(db.Model, UserMixin):
__tablename__ = 'account'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(50), nullable=True)
email = db.Column(db.String(200), nullable=True)
password = db.Column(db.String(200), nullable=True)
img = db.Column(db.String(200), nullable=True, default='default.jpg')
followings = db.relationship(
'Account',
secondary=account_subs,
primaryjoin=(account_subs.c.follower_id == id),
secondaryjoin=(account_subs.c.following_id == id),
backref=db.backref('followers', lazy='dynamic'),
)
stars = db.relationship('Post',
secondary=post_subs,
backref=db.backref('subscribers', lazy='dynamic'))
messages_sent = db.relationship('Message',
foreign_keys='Message.sender_id',
backref='author',
lazy='dynamic')
messages_recieved = db.relationship('Message',
foreign_keys='Message.recipient_id',
backref='recipient',
lazy='dynamic')
last_message_read_time = db.Column(db.DateTime)
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()
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 Account.query.get(user_id)
class Token(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_expired = db.Column(db.DateTime, nullable=False)
token = db.Column(db.String(60), nullable=False, index=True,
unique=True) # index helps speeding up the searching
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship(User, backref=db.backref('tokens', 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=True, default='default.jpg')
password = db.Column(db.String(60), nullable=False)
is_active = db.Column(db.Boolean, nullable=True, default=True)
is_banned = db.Column(db.Boolean, nullable=True, default=False)
posts = db.relationship('Post', backref='author', lazy=True)
roles = db.relationship('Role',
secondary='user_role',
backref=db.backref('users', lazy='dynamic'))
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}')"
def has_roles(self, *args):
return set(args).issubset({role.name for role in self.roles})
@property
def is_administrator(self):
return {"admin"}.issubset({role.name for role in self.roles})
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)
level = db.Column(db.String(20), nullable=False)
posts = db.relationship('Post', backref='student', lazy=True)
memberof = db.relationship('Clubs',
secondary=membership,
backref=db.backref('members', lazy='dynamic'))
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"('{self.id}','{self.username}')"
class Comment(db.Model):
"""docstring for Comment"""
_N = 6
__tablename__: "comment"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
timestamp = db.Column(db.DateTime(),
nullable=False,
default=datetime.utcnow,
index=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
path = db.Column(db.Text, index=True)
parent_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
replies = db.relationship('Comment',
backref=db.backref('parent', remote_side=[id]),
lazy='dynamic')
def save(self):
db.session.add(self)
db.session.commit()
prefix = self.parent.path + '.' if self.parent else ''
self.path = prefix + '{:0{}d}'.format(self.id, self._N)
db.session.commit()
def level(self):
return len(self.path) // self._N - 1
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=db.backref('author', lazy=True))
def get_reset_token(self, expires_sec=1800):
#Create a serializer object (SecretKey, expirationTime)
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
#return a token created with this serializer
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
#Creates a serializer
s = Serializer(current_app.config['SECRET_KEY'])
try:
#tries to load the token parameter and get the user_id
user_id = s.loads(token)['user_id']
except:
#If exception return None
return None
# If no exception returns the user with that user_id
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Post(db.Model):
__searchable__ = ['title', 'body']
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), unique=True, nullable=False)
slug = db.Column(db.String(200), unique=True, nullable=False)
body = db.Column(db.Text, nullable=False)
category = db.Column(db.String(100), nullable=False)
image = db.Column(db.String(150), nullable=False, default='no-image.jpg')
user_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
author = db.relationship('User',
backref=db.backref('posts',
lazy=True,
passive_deletes=True))
views = db.Column(db.Integer, default=0)
comments = db.Column(db.Integer, default=0)
feature = db.Column(db.String, default=1, nullable=False)
date_pub = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
return '<Post %r' % self.title
@staticmethod
def generate_slug(target, value, oldvalue, initiator):
if value and (not target.slug or value != oldvalue):
target.slug = slugify(value)
class User(db.Model, UserMixin, Base):
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)
messages = db.relationship('Message', backref='author', lazy=True)
coach_id = db.Column(db.Integer, db.ForeignKey('user.id'))
clients = db.relationship("User",
backref=db.backref('coach', remote_side=[id]))
is_client = db.Column(db.Boolean, default=False)
images = db.relationship('Image', backref='client', lazy=True)
def get_reset_token(self, expires_sec=1800):
#1800 seconds = 30 mins
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.username}','{self.email}','{self.image_file}')"
class Guideline(db.Model):
guide_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), nullable=False)
authors = db.Column(db.String(200), nullable=False)
referenced_by = db.relationship('Publication',
secondary=association_guideline,
backref=db.backref('guidelines',
lazy='dynamic'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
fullname = db.Column(db.String(60))
email = db.Column(db.String(20), unique=True)
address = db.Column(db.String(120))
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
points = db.Column(db.Integer)
posts = db.relationship('Post', backref='post_author', lazy=True)
fishes = db.relationship('Fish', backref='fish_seller', lazy='dynamic')
mycarousel = db.relationship('Mycarousel',
backref='author',
lazy='dynamic')
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 f"User('{self.username}', '{self.email}', '{self.image_file}')"
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 is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Fish.query.join(
followers, (followers.c.followed_id == Fish.seller_id)).filter(
followers.c.follower_id == self.id)
own = Fish.query.filter_by(seller_id=self.id)
return followed.union(own).order_by(Fish.upload_date.desc())
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)
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)
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
admin = db.Column(db.Boolean())
notes = db.Column(db.UnicodeText)
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 __init__(self, username, email, password, notes='', admin=False):
self.username = username
self.email = email
self.password = password
self.admin = admin
self.notes = notes
def is_admin(self):
return self.admin
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
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)
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 is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
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 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=db.backref('author', lazy=True))
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Comment(db.Model):
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)
date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
status = db.Column(db.Boolean,
default=False) # used for showed after approve
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
post = db.relationship('Post', backref=db.backref('post', lazy=True))
def __repr__(self):
return f"Comment('{self.name}', '{self.email}', '{self.message}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.now(timezone('Europe/Moscow')))
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
tags = db.relationship('Tag',
secondary=post_tags,
backref=db.backref('posts', lazy='dynamic'))
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
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)
content_type = db.Column(db.String(20), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
author = db.relationship(User, backref=db.backref('posts', lazy=True))
def __repr__(self):
return f"<Post(id='{self.id}', user_id='{self.user_id}', title='{self.title}', date_posted='{self.date_posted}')>"
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)
notesmapped = db.relationship('Tag',
secondary=notemapper,
backref=db.backref('notesmapped',
lazy='dynamic'))
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class Comments(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), 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', ondelete='CASCADE'),
nullable=False)
post = db.relationship('Post',
backref=db.backref('posts',
lazy=True,
passive_deletes=True))
feature = db.Column(db.Boolean, default=False, nullable=False)
date_pub = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
return '<Post %r' % self.name
class Post(db.Model):
__tablename__ = 'post'
__searchable__ = ['date_posted', 'tags']
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)
tags = db.relationship('Tag',
secondary=tags,
lazy='subquery',
backref=db.backref('pages', lazy=True))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}', {self.tags})"
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)
about = db.Column(db.Text(), default="Kiedyś to uzupełnie")
role = db.Column(db.Text(), default="user")
is_verified = db.Column(db.Text(), default="no")
__searchable__ = ['username']
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 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 is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.image_file}')"
class Events(db.Model): #2 FK declare for User-Event and Event and Creator?
id = db.Column(db.Integer, primary_key=True)
event_name = db.Column(db.String(100), nullable=False)
event_description = db.Column(db.String(1000), nullable=False)
user_capacity = db.Column(db.Integer, nullable=False)
time_start = db.Column(db.Integer, nullable=False) #dc data type
time_end = db.Column(db.Integer, nullable=False) #dc data type
tag = db.Column(db.String(10))
#fk
venue_id = db.Column(db.Integer, db.ForeignKey('venue.id'), nullable=False)
tag_id = db.Column(db.Integer, db.ForeignKey('tag.id'), nullable=False)
sport_id = db.Column(db.Integer, db.ForeignKey('sport.id'), nullable=False)
#For Creator function if we want to implement later
User_Event = db.relationship('User_Event',
secondary=UserEvent,
lazy='subquery',
backref=db.backref('event', lazy=True))
def __repr__(self):
return f"Events('{self.event_name}', '{self.event_description}', '{self.user_capacity}', '{self.time_start}', '{self.time_end}', '{self.tag}')"
class Fish(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), nullable=False)
upload_date = db.Column(db.DateTime,
index=True,
nullable=False,
default=datetime.utcnow)
image_file = db.Column(db.String(20), nullable=False)
price = db.Column(db.Integer, nullable=False)
unit = db.Column(db.String(20), nullable=False) # kg,g
size = db.Column(db.String(20), nullable=False) #Small, Medium, Large
pc_vatta = db.Column(db.Integer)
price_vatta = db.Column(db.Integer)
isAvailable = db.Column(db.Boolean, nullable=False, default=False)
orders = db.relationship('Order',
secondary=ords,
backref=db.backref('fishes'),
lazy='dynamic')
seller_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Fish('{self.name}', '{self.price}', '{self.isAvailable}')"
class Users(db.Model, UserMixin
): #No FK in table, declare FK in venue, UserEvent, and Event
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
first_name = db.Column(db.String(40), nullable=False)
last_name = db.Column(db.String(40), nullable=False)
street_Address = db.Column(db.String(40), nullable=False)
city = db.Column(db.String(40), nullable=False)
state = db.Column(db.String(20), nullable=False)
password = db.Column(db.String(60), nullable=False)
admin = db.Column(db.Boolean, nullable=False)
#FK
#Venue = db.relationhsips('Venue', db.ForeignKey('user.id'), lazy=True, backref='AdminCreator')
#For referencing Creator purpose
UserEvent = db.relationship('User_Event',
secondary=UserEvent,
lazy='subquery',
backref=db.backref(
'users', lazy=True)) #for user event table
#Event = db.relationship('Event', lazy='subquery', backref='users') #for Event participation table
#For Creator purposes
def __repr__(self):
return f"Users({self.email}', '{self.first_name}', '{self.last_name}', '{self.street_Address}', '{self.state}', '{self.city}', '{self.admin}')"
class Friend(db.Model):
id = db.Column(db.Integer, primary_key=True)
users = db.relationship('User',
secondary=friends,
lazy='subquery',
backref=db.backref('friends,lazy=True'))
class User(db.Model, UserMixin):
__tablename__ = 'users'
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')
about_me = db.Column(db.Text())
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
followed = db.relationship('Follow',
foreign_keys=[Follow.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
comments = db.relationship('Comment', backref='author', lazy='dynamic')
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)
@staticmethod
def add_self_follows():
for user in User.query.all():
if not user.is_following(user):
user.follow(user)
db.session.add(user)
db.session.commit()
def follow(self, user):
if not self.is_following(user):
f = Follow(follower=self, followed=user)
db.session.add(f)
def unfollow(self, user):
f = self.followed.filter_by(followed_id=user.id).first()
if f:
db.session.delete(f)
def is_following(self, user):
if user.id is None:
return False
return self.followed.filter_by(followed_id=user.id).first() is not None
def is_followed_by(self, user):
if user.id is None:
return False
return self.followers.filter_by(
follower_id=user.id).first() is not None
@property
def followed_posts(self):
return Post.query.join(Follow, Follow.followed_id == Post.author_id)\
.filter(Follow.follower_id == self.id)
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return None
return User.query.get(data['id'])
def to_json(self):
json_user = {
'url':
url_for('api.get_user', id=self.id),
'username':
self.username,
'posts_url':
url_for('api.get_user_posts', id=self.id),
'followed_posts_url':
url_for('api.get_user_followed_posts', id=self.id),
'post_count':
self.posts.count()
}
return json_user
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(120),
nullable=False,
default='default.jpeg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
comments = db.relationship('Comment', backref='author', lazy=True)
children_upvoted_posts = db.relationship('Upvote_association',
back_populates='user')
children_downvoted_posts = db.relationship('Downvote_association',
back_populates='user')
domains = db.relationship('Domain', backref='creator', lazy=True)
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers',
viewonly=True,
lazy='dynamic',
sync_backref=False),
lazy='dynamic')
followed_domain = db.relationship(
'Domain',
secondary=domain_followers,
primaryjoin=(domain_followers.c.follower_id == id),
secondaryjoin=(domain_followers.c.followed_id == Domain.id),
backref=db.backref('followers',
viewonly=True,
lazy='dynamic',
sync_backref=False),
lazy='dynamic')
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}')"
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
db.session.commit()
return self
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
db.session.commit()
return self
def is_following_domain(self, domain):
return self.followed_domain.filter(
domain_followers.c.followed_id == domain.id).count() > 0
def follow_domain(self, domain):
if not self.is_following_domain(domain):
self.followed_domain.append(domain)
db.session.commit()
return self
def unfollow_domain(self, domain):
if self.is_following_domain(domain):
self.followed_domain.remove(domain)
db.session.commit()
return self
