class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
userid = db.Column(db.Integer(32))
articleid = db.Column(db.Integer(32))
content = db.Column(db.String(2048), nullable=False)
create_time = db.Column(db.DateTime, nullable=True, default=datetime.now)
def __repr__(self):
return '<User %r>' % self.content
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE'))
def __repr__(self):
return f"UserRoles('{self.id}', '{self.user_id}', '{self.role_id}')"
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 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 Comments(db.Model):
id = db.Column(db.Integer(), primary_key=True)
post_id = db.Column(db.Integer(), db.ForeignKey('post.id'), nullable=False)
author_id = db.Column(db.Integer(),
db.ForeignKey('user.id'),
nullable=False)
content = db.Column(db.Text, nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.now)
def __repr__(self):
return f"Comments('{self.id}', '{self.post_id}', '{self.author_id}')"
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 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)
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 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 Post(db.Model):
id = db.Column(db.Integer(), primary_key=True)
author_id = db.Column(db.Integer(),
db.ForeignKey('user.id'),
nullable=False)
title = db.Column(db.String(128), nullable=False)
content = db.Column(db.Text, nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.now)
comments = db.relationship('Comments',
backref='post',
lazy=True,
order_by='Comments.date_posted.desc()')
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class Anuncio(db.Model):
__tablename__ = "anuncio"
id = db.Column(db.Integer, primary_key=True)
titulo = db.Column(db.String(200))
jornada = db.Column(db.Enum(EnumJornada))
qtde_vagas = db.Column(db.Integer())
descricao = db.Column(db.Text)
valor = db.Column(db.Numeric(10, 2))
data_pub = db.Column(db.DateTime)
id_empresa = db.Column(db.Integer, db.ForeignKey('empresa.id', ondelete='CASCADE'))
id_categoria = db.Column(db.Integer, db.ForeignKey('categoria.id', ondelete='CASCADE'))
def __init__(self, titulo, descricao, valor, qtde_vagas, id_empresa, id_categoria, jornada, data_pub):
self.titulo = titulo
self.descricao = descricao
self.valor = valor
self.qtde_vagas = qtde_vagas
self.id_empresa = id_empresa
self.id_categoria = id_categoria
self.jornada = jornada
self.data_pub = data_pub
def __repr__(self):
return "<Post %r>" % self.id
class User(UserMixin, db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True)
email = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
profile_picture = db.Column(db.String(40))
bio = db.Column(db.String(100))
firstname = db.Column(db.String(30))
lastname = db.Column(db.String(30))
address = db.Column(db.String(30))
country = db.Column(db.String(12))
phone_number = db.Column(db.Integer())
posts = db.relationship('Post', backref='user', lazy=True)
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')
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@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)
### REPRESENTATION METHOD CODE GOES HERE ###
def __repr__(self):
return f"User('{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), 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(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 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 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))
posts = db.relationship('Post', backref="author")
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(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 Post(db.Model):
__searchable__ = ['title', 'content']
id = db.Column(db.Integer, primary_key=True)
date_posted = db.Column(db.DateTime, default=datetime.utcnow)
title = db.Column(db.String(90), nullable=True, default='')
content = db.Column(db.String(3000), nullable=False)
# contentPrv = db.Column(db.String(150), nullable=False)
image_file = db.Column(db.String(60))
category = db.Column(db.String(20), default='Public')
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'), nullable=False)
likes = db.relationship('PostLike', backref='post', lazy='dynamic')
def __repr__(self):
return f"Post('{self.date_posted}', '{self.title}')"
class User(UserMixin, db.Model):
id = db.Column(db.Integer(), primary_key=True)
user_name = db.Column(db.String(30), nullable=False)
email = db.Column(db.String(100), nullable=False)
password_hash = db.Column(db.String(100), nullable=False)
avatar_path = db.Column(db.String(100), default='/static/images/logo.jpg')
posts = db.relationship('Post', backref='author', lazy='dynamic')
def __init__(self, user_name, email, password):
self.user_name = user_name
self.email = email
self.password_hash = generate_password_hash(password)
def __repr__(self):
return '<User %r>' % self.user_name
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(length=30), unique=True, nullable=False)
email = db.Column(db.String(length=40), unique=True, nullable=False)
password_hash = db.Column(db.String(length=40), nullable=False)
posts = db.relationship('Post', backref='owned_user', lazy=True)
comments = db.relationship('Comment', backref='owned_user', lazy=True)
@property
def password(self):
return self.password
@password.setter
def password(self, plain_text):
self.password_hash = bcrypt.generate_password_hash(plain_text).decode(
'utf-8')
def check_password(self, attempted_password):
return bcrypt.check_password_hash(self.password_hash,
attempted_password)
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 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(128), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
active = db.Column(db.Boolean(), nullable=False, default=0)
posts = db.relationship('Post', backref='author', lazy=True)
comments = db.relationship('Comments', backref='author', lazy=True)
roles = db.relationship('Role',
secondary='user_roles',
backref=db.backref('user', lazy=True),
lazy='subquery')
@property
def roles_names(self):
return [role.name for role in User.query.get(self.id).roles]
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}')"
from flask_security import RoleMixin, UserMixin
from blog import db
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')),
)
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 Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(255))
description = db.Column(db.String(255))
class Role(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
def __repr__(self):
return f"Role('{self.id}', '{self.name}')"
import datetime
import flask_login
from werkzeug import security as sec
@login_mngr.user_loader
def load_user(id):
id = int(id)
user = User.query.get(id)
return user
followers = db.Table(
'followers',
db.Column('follower_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('followed_id', db.Integer(), db.ForeignKey('user.id')))
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),
from blog import db,app
from datetime import datetime
from blog import login_manager
from flask_login import UserMixin
from flask_security import Security, SQLAlchemyUserDatastore,UserMixin, RoleMixin
from flask_security.forms import RegisterForm
from wtforms.validators import ValidationError
from wtforms import StringField
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
#Roles And User Relationship
roles_users = db.Table('roles_users',db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
#Role For Admin
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
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):
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
