class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text(30), nullable=False, unique=True)
content = db.Column(db.Text(900), nullable=False)
date = db.Column(db.DateTime, default=datetime.datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f'{self.__class__.__name__}({self.id}-{self.title}-{self.date})'
def __str__(self):
return self.content[:40]
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(150), nullable=False)
content = db.Column(db.Text(500), nullable=False)
#dated_posted= db.Column(db.DateTime,default =datetime.now)
date_posted = db.Column(db.DateTime, default=datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
class Contact(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(40), nullable=False)
email = db.Column(db.String(40), nullable=False)
subject = db.Column(db.String(255), nullable=False)
message = db.Column(db.Text(), nullable=False)
def __repr__(self):
return self.username
class Comment(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(30), nullable=False)
text = db.Column(db.Text())
data = db.Column(db.DateTime())
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
def __repr__(self):
return '<Comment %s>' % self.name
class Blog(db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),db.ForeignKey('user.id'))
title = db.Column(db.String(40), nullable=False)
description = db.Column(db.Text(), nullable=False)
image = db.Column(db.String(500), nullable=False)
created_at= db.Column(db.DateTime(timezone=True),server_default=func.now())
is_published = db.Column(db.Boolean(), default=True, nullable=False)
def __repr__(self):
return self.username
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now)
title = db.Column(db.String(120), nullable=False)
description = db.Column(db.String(240))
body = db.Column(db.Text(), nullable=False)
slug = db.Column(db.String(250))
image = db.Column(db.String(120))
def __repr__(self):
return f"Post('{ self.id }', '{ self.title }')"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30), unique=True, nullable=False)
password = db.Column(db.String(30), unique=True, nullable=False)
email = db.Column(db.Text(50), unique=True, nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f'{self.__class__.__name__}({self.username}-{self.email})'
def __str__(self):
return self.username
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True)
display_name = db.Column(db.String(100))
password_hash = db.Column(db.Text())
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 __repr__(self):
return self.name
class Post(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text(), nullable=False)
post_time = db.Column(db.TIMESTAMP(True),
server_default=text('CURRENT_TIMESTAMP'),
nullable=False)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False)
def __init__(self, title, content):
self.title = title
self.content = content
def __repr__(self):
return '<Post %r>' % self.title
class BlogPost(db.Model):
__tablename__ = 'blogposts'
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(160), nullable=False)
content = db.Column(db.Text(4000), nullable=False)
def __init__(self, title, content, user_id):
self.title = title
self.content = content
self.user_id = user_id
def __repr__(self):
return f"Post ID: {self.id}"
class User(db.Model, UserMixin):
__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(64), index=True, unique=True)
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
name = db.Column(db.String(64))
location = db.Column(db.String(64))
about_me = db.Column(db.Text())
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
last_seen = db.Column(db.DateTime(), default=datetime.utcnow)
posts = db.relationship('Post', backref='author', lazy='dynamic')
password_hash = db.Column(db.String(128))
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 __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.role is None:
if self.email == current_app.config['BLOG_ADMIN']:
self.role = Role.query.filter_by(permissions=0xff).first()
if self.role is None:
self.role = Role.query.filter_by(default=True).first()
@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 can(self, permissions):
return self.role is not None and \
(self.role.permissions & permissions) == permissions
def is_admin(self):
return self.can(Permission.ADMINISTER)
def ping(self):
self.last_seen = datetime.utcnow()
db.session.add(self)
db.session.commit()
def follow(self, user):
f = Follow(follower=self, followed=user)
db.session.add(f)
db.session.commit()
def unfollow(self, user):
f = self.followed.filter_by(followed_id=user.id).first()
if f:
db.session.delete(f)
db.session.commit()
def is_following(self, user):
return self.followed.filter_by(followed_id=user.id).first() \
is not None
def is_followed_by(self, user):
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)
@property
def self_posts(self):
return self.posts.filter_by(author_id=self.id)
def __repr__(self):
return '<User %r>' % self.username
@staticmethod
def generate_fake(count=100):
from sqlalchemy.exc import IntegrityError
from random import seed
import forgery_py
seed()
for i in range(count):
u = User(email=forgery_py.internet.email_address(),
username=forgery_py.internet.user_name(True),
password=forgery_py.lorem_ipsum.word(),
name=forgery_py.name.full_name(),
location=forgery_py.address.city(),
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
db.session.add(u)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
