class Post(db.Model):
__tablename__ = "post"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), unique=True, nullable=False)
content = db.Column(db.Text, unique=False, nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
time_created = db.Column(db.DateTime(timezone=True),
server_default=func.now())
time_updated = db.Column(db.DateTime(timezone=True), onupdate=func.now())
def __repr__(self):
return "<Post {}>".format(self.title)
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}'
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(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):
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='post', lazy=True)
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=False)
email = db.Column(db.String(64), unique=False)
message = db.Column(db.String(250), index=False, nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
date_posted = db.Column(db.DateTime())
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 Post(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(30))
body = db.Column(db.String(50))
timestamp = db.Column(db.DateTime())
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
comments = db.relationship('Comment', backref='post', lazy='dynamic')
def __repr__(self):
return '<Post %s>' % self.title
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)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}','{self.date_posted}','{self.content}')"
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 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 Abbonati(db.Model):
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(40), nullable=False)
scadenza = db.Column(db.DateTime(), nullable=False, default=datetime.utcnow)
cell = db.Column(db.String(20), nullable=False)
quota = db.Column(db.Integer, nullable=False)
versato = db.Column(db.Integer, nullable=False, default=0)
note = db.Column(db.String(100), nullable=False, default='')
end_near = db.Column(db.Boolean, nullable=False, default=False)
def __repr__(self):
return f"Abbonati('{self.nome}', '{self.scadenza}', '{self.cell}', '{self.quota}', '{self.versato}', '{self.note}')"
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 Post(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(length=100), nullable=False)
post = db.Column(db.String(length=1000), nullable=False)
rating = db.Column(db.Float(), nullable=False, default=0.0)
date = db.Column(db.DateTime(), nullable=False, default=datetime.utcnow)
owner = db.Column(db.Integer(), db.ForeignKey('user.id'))
comments = db.relationship('Comment', backref='owned_post', lazy=True)
def set_owner(self):
self.owner = current_user.id
db.session.commit()
class Comment(db.Model):
id = db.Column(db.Integer(), primary_key=True)
comment = db.Column(db.String(length=1000), nullable=False)
like = db.Column(db.Integer(), nullable=False, default=0)
date = db.Column(db.DateTime(), nullable=False, default=datetime.utcnow)
owner_user = db.Column(db.Integer(), db.ForeignKey('user.id'))
owner_post = db.Column(db.Integer(), db.ForeignKey('post.id'))
def set_comment_owner(self, post_id):
self.owner_user = current_user.id
self.owner_post = post_id
db.session.commit()
class Comment(db.Model):
__tablename__ = 'comment'
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String(50))
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
date_posted = db.Column(db.DateTime(),
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
def __repr__(self):
return f"Comment('{self.content}', '{self.date_posted}', '{self.author}')"
class Post(db.Model):
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(32))
content = db.Column(db.Text())
date = db.Column(db.DateTime(), default=datetime.datetime.now())
author_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
def __repr__(self):
return "<Post {}>".format(self.title)
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 WeatherPoint(db.Model):
id = db.Column(db.Integer, primary_key=True)
city = db.Column(db.String(32))
country = db.Column(db.String(32))
timestamp = db.Column(db.DateTime(),index=True,)
temp = db.Column(db.Float(precision=2))
feels_like = db.Column(db.Float(precision=2))
wind_spd = db.Column(db.Float(precision=2))
description = db.Column(db.String(16))
icon = db.Column(db.String(8))
precipitation = db.Column(db.Float(precision=2))
def __repr__(self):
return f"<{self.city}/{self.country} on {self.timestamp}>".capitalize()
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 Post(db.Model):
__tablename__ = 'post'
def __init__(self, title, content, category, user_id, date_created, author,
post_image_location):
self.title = title
self.content = content
self.date_created = date_created
self.author = author
self.post_image_location = post_image_location
self.category = category
self.user_id = user_id
id = db.Column(db.Integer(), primary_key=True)
title = db.Column(db.String(50), nullable=False)
content = db.Column(db.String(800), nullable=False)
date_created = db.Column(db.DateTime())
category = db.Column(db.String(20), nullable=False)
author = db.Column(db.String(40), index=True)
post_image_location = db.Column(db.String(30), index=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
post = db.relationship('Comment', backref='comments', lazy=True)
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)
date_posted = db.Column(db.DateTime(), nullable=False, default=datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
class Blogpost(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50))
intro = db.Column(db.String(50))
date_published = db.Column(db.DateTime(timezone=True), default=func.now())
content = db.Column(db.Text)
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()
