class Follow(db.Model):
__tablename__ = "follow"
id = db.column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
follower_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', foreign_keys=user_id)
follower = db.relationship('User', foreign_keys=follower_id)
class Artist(db.Model):
id = db.Column(db.Integer, primary_key=True)
artist = db.Column(db.String(100), index=True)
about = db.Column(db.String(200))
disc_artist = db.relationship("Disc", backref="artist", lazy="dynamic")
disc_a_d = db.relationship("ArtistDisc", backref="artist", lazy="dynamic")
def __str__(self):
return f"<Artist: {self.name}>"
class Disc(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text, index=True)
genre = db.Column(db.Text)
year = db.Column(db.Integer)
description = db.Column(db.Text)
artist_id = db.Column(db.Integer, db.ForeignKey('artist.id'))
artists = db.relationship("ArtistDisc", backref="disc", lazy="dynamic")
rented = db.relationship("Rented", backref="disc", lazy="dynamic")
def __str__(self):
return f"<Book: {self.id} {self.title[:50]}...>"
class Project(db.Model):
__tablename__ = "project"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text())
goal = db.Column(db.Float)
current_amount = db.Column(db.Float)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
school_id = db.Column(db.String(120), db.ForeignKey('school.id'))
transactions = db.relationship('Transaction')
reports = db.relationship('Report')
def __repr__(self):
return '<Project %r>' % self.title
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey("stores.id"))
store = db.relationship('StoreModel')
def __init__(self, name, price,store_id):
self.name = name
self.price = price
self.store_id = store_id
def json(self):
return {'name': self.name, 'price': self.price}
@classmethod
def find_by_name(cls, name):
# SELECT * FROM items WHERE name=name LIMIT 1
return ItemModel.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class School(db.Model):
__tablename__ = "school"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
logo = db.Column(db.String(240), nullable=False)
color = db.Column(db.String(120), nullable=False)
members = db.relationship('User')
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer())
roles = db.relationship(
'Role',
secondary=role_users,
backref=db.backref('users', lazy='dynamic')
)
def get_security_payload(self):
return {
'id': self.id,
'name': self.name,
'email': self.email,
}
def __str__(self):
return self.email
class StoreModel(db.Model):
__tablename__ = 'stores'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
items = db.relationship('ItemModel', lazy='dynamic')
def __init__(self, name, price):
self.name = name
self.price = price
def json(self):
return {'name': self.name, 'items': [item.json() for item in self.items.all()]}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
users = db.relationship('User', backref='role', lazy='dynamic')
def __repr__(self):
return '<Role %r>' % self.name
class OAuth(OAuthConsumerMixin, db.Model):
"""Data model for oauth accounts."""
__tablename__ = 'oauth'
provider_user_id = db.Column(db.String(256), unique=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False)
user = db.relationship("User", back_populates="oauth", uselist=False)
class Log(OurMixin, db.Model):
__tablename__ = 'logs'
id = db.Column(db.VARCHAR(length=36), primary_key=True)
action = db.Column(db.VARCHAR(length=5120))
user_id = db.Column(db.VARCHAR(length=36),
db.ForeignKey('users.id', ondelete='CASCADE'),
nullable=False)
user = db.relationship("User", cascade='delete')
class Article(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)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship(User, backref=db.backref('articles', uselist=True))
def __repr__(self):
return '<Article %s>' % self.title
class Tag(SurrogatePK, Model):
__tablename__ = 'tags'
tag = db.Column(db.Text)
posts = db.relationship('Post', secondary=tags_posts, backref=db.backref('tags_br', lazy='dynamic'))
def __init__(self, tag, **kwargs):
db.Model.__init__(self, tag=tag, **kwargs)
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Unicode(20), unique=True)
email = db.Column(db.Unicode(40), unique=True)
password = db.Column(db.Unicode(30), unique=True)
listings = db.relationship('Items', backref='user', lazy=True)
def __repr__(self):
return '<User: %r>' % self.username + self.email + self.password
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key= True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey('stores.id'))
store = db.relationship('StoreModel')
def __init__(self, name, price, store_id):
self.name = name
self.price = price
self.store_id = store_id
def json(self):
return {'name': self.name, 'price': self.price}
@classmethod
def find_by_name(cls, name):
# connection = sqlite3.connect('data.db')
# cursor = connection.cursor()
# query = "SELECT * FROM items WHERE name=?"
# result = cursor.execute(query, (name,))
# row = result.fetchone()
# connection.close()
#
# if row:
# return cls(*row)
return ItemModel.query.filter_by(name=name).first()
def save_to_db(self):
# connection = sqlite3.connect('data.db')
# cursor = connection.cursor()
# query = 'INSERT INTO items VALUES(?,?)'
# cursor.execute(query, (self.name, self.price))
#
# connection.commit()
# connection.close()
db.session.add(self)
db.session.commit()
# def update(self):
# connection = sqlite3.connect('data.db')
# cursor = connection.cursor()
#
# query = 'UPDATE items SET price=? WHERE NAME=?'
# cursor.execute(query, (self.name, self.price))
#
# connection.commit()
# connection.close()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class StoreModel(db.Model):
__tablename__ = 'stores'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
items = db.relationship('ItemModel', lazy='dynamic')
def __init__(self,name):
self.name = name
class User(db.Model):
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)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Puppy(db.Model):
__tablename__ = 'puppies'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
owner = db.relationship('Owner', backref='Puppy', uselist=False)
date = db.Column(db.DateTime, default=est_now)
def __init__(self, name):
self.name = name
def __repr__(self):
return f'{self.name}'
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
firstname = db.Column(db.String(80), nullable=False)
lastname = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120))
userType = db.Column(db.Integer, nullable=False)
paypal = db.Column(db.String(250))
verified = db.Column(db.Boolean, nullable=False)
school = db.Column(db.Integer, db.ForeignKey('school.id'))
pic = db.Column(db.Text())
projects = db.relationship('Project')
# reports_made = db.relationship('Report', foreign_keys=['reports.reporting_user'])
# reports_against = db.relationship('Report', foreign_keys=['reports.reportee_id'])
messages = db.relationship('Message')
##Lazy loading refers to objects are returned from a
##query without the related objects loaded at first.
def __repr__(self):
return '<User %r>' % self.username
class Post(SurrogatePK, Model):
__tablename__ = 'posts'
title = db.Column(db.Text)
slug = db.Column(db.Text)
body = db.Column(db.Text)
created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
tags = db.relationship('Tag', secondary=tags_posts, backref=db.backref('posts_br', lazy='dynamic'))
def __init__(self, title, slug, body, **kwargs):
db.Model.__init__(self, title=title, slug=slug, body=body, **kwargs)
class File(OurMixin, db.Model):
__tablename__ = 'files'
id = db.Column(db.VARCHAR(length=36), primary_key=True)
name = db.Column(db.VARCHAR(length=256), nullable=False)
path = db.Column(db.VARCHAR(length=512), nullable=True)
thumbnail_name = db.Column(db.VARCHAR(length=256), nullable=True)
thumbnail_path = db.Column(db.VARCHAR(length=512), nullable=True)
width = db.Column(db.Integer(), default=0, server_default='0')
height = db.Column(db.Integer(), default=0, server_default='0')
size = db.Column(db.Integer(), default=0, server_default='0')
user_id = db.Column(db.VARCHAR(length=36), db.ForeignKey('users.id'), nullable=False)
user = db.relationship("User")
mimetype = db.Column(db.VARCHAR(length=256), nullable=False)
class Post(db.Model):
__tablename__ = "posts"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
user_id = db.Column(dm.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', foreign_keys=user_id)
def __init__(self, content, user_id):
self.content = content
self.user_id = user_id
def __repr(self):
return f"<Post {self.id}>"
class User(db.Model, UserMixin):
"""Data model for user accounts."""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), index=False, unique=False, nullable=False)
email = db.Column(db.String(80), index=True, unique=False, nullable=False)
created = db.Column(db.DateTime, index=False, unique=False, nullable=False)
password = db.Column(db.String(255), nullable=False)
token = db.Column(db.String(80), index=True, unique=True)
token_expiration = db.Column(db.DateTime)
oauth = db.relationship("OAuth", back_populates="user", uselist=False)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.created = DATE
self.token = token_urlsafe()
self.token_expiration = DATE
self.password = generate_password_hash(self.password, method='sha256')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password = generate_password_hash(password, method='sha256')
def check_password(self, password):
return check_password_hash(self.password, password)
@property
def to_dict(self):
return {
'user_id': self.id,
'username': self.username,
'email': self.email,
'created': str(self.created),
}
def verify_expiration_token(self):
now = datetime.now()
if now > self.token_expiration + timedelta(minutes=60):
self.token = token_urlsafe()
self.token_expiration = now
return self.token
class TokenBlocklist(db.Model):
"""Blocklist representation"""
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(36), nullable=False, unique=True)
token_type = db.Column(db.String(10), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
revoked = db.Column(db.Boolean, nullable=False)
expires = db.Column(db.DateTime, nullable=False)
user = db.relationship("User", lazy="joined")
def to_dict(self):
return {
"token_id": self.id,
"jti": self.jti,
"token_type": self.token_type,
"user_identity": self.user_identity,
"revoked": self.revoked,
"expires": self.expires,
}
class Tarea(db.Base):
__tablename__ = 'tarea'
id = Column(Integer, primary_key = True)
titulo = Column(String(60))
descripcion = Column(String(255))
estado = Column(String(60))
fecha_creacion = Column(String(60))
responsable = db.Column(db.Integer, db.ForeignKey('usuario.id'))
usuario = db.relationship("Usuario", backref = "tarea")
def __init__ (self, titulo, descripcion, estado, responsable, fecha_creacion):
self.titulo = titulo
self.descripcion = descripcion
self.estado = estado
self.responsable = responsable
self.fecha_creacion = fecha_creacion
def __repr__(self):
return f'{self.id}, {self.titulo}, {self.descripcion}, {self.estado}, {self.responsable}, {self.fecha_creacion}'
class TokenBlacklist(db.Model):
"""Blacklist representation
"""
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(36), nullable=False, unique=True)
token_type = db.Column(db.String(10), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
revoked = db.Column(db.Boolean, nullable=False)
expires = db.Column(db.DateTime, nullable=False)
user = db.relationship('User', lazy='joined')
def to_dict(self):
return {
'token_id': self.id,
'jti': self.jti,
'token_type': self.token_type,
'user_identity': self.user_identity,
'revoked': self.revoked,
'expires': self.expires
}
class Role(OurMixin, db.Model):
"""
Subclass this for your roles
"""
__tablename__ = 'roles'
id = db.Column(db.VARCHAR(length=36), primary_key=True)
name = db.Column(db.String(120), unique=True)
abilities = db.relationship(
'Ability', secondary=role_abilities_table, backref='roles')
def __init__(self, name):
self.name = name.lower()
# self.id = uuid()
super(Role, self).__init__()
def add_abilities(self, *abilities):
for ability in abilities:
existing_ability = Ability.query.filter_by(
name=ability).first()
if not existing_ability:
existing_ability = Ability(ability)
existing_ability.insert()
# safe_commit()
# db.session.commit()
self.abilities.append(existing_ability)
def remove_abilities(self, *abilities):
for ability in abilities:
existing_ability = Ability.query.filter_by(name=ability).first()
if existing_ability and existing_ability in self.abilities:
self.abilities.remove(existing_ability)
def __repr__(self):
return '<Role {}>'.format(self.name)
def __str__(self):
return self.name
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
users = db.relationship('User', backref='role')
class User(UserMixin, OurMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.VARCHAR(length=36), primary_key=True)
username = db.Column(db.String())
firstname = db.Column(db.String(32))
lastname = db.Column(db.String(32))
password = db.Column(db.String())
active = db.Column(db.Boolean(), default=True, server_default='1')
_roles = db.relationship(
'Role', secondary=user_role_table, backref='users')
type = db.Column(db.String(50))
roles = association_proxy('_roles', 'name', creator=_role_find_or_create)
def __init__(self, **kwargs):
# A bit of duplication here keeps the kwargs being
# set but encrypts the password.
for k, v in kwargs.items():
if k != 'password':
setattr(self, k, v)
else:
self.set_password(v)
OurMixin.__init__(self)
UserMixin.__init__(self)
def validate(self):
return_value = success()
not_unique = User.filter(User.username == self.username).count()
if not_unique:
return_value['success'] = False
return_value['messages'].append("That user exists already.")
if not self.email:
return_value['success'] = False
return_value['messages'].append("An email address is required to create a user.")
return return_value
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, value):
return check_password_hash(self.password, value)
def is_authenticated(self):
if isinstance(self, AnonymousUserMixin):
return False
else:
return True
def is_active(self):
return self.active
def is_anonymous(self):
if isinstance(self, AnonymousUserMixin):
return True
else:
return False
def add_roles(self, *roles):
self.roles.extend([role for role in roles if role not in self.roles])
def remove_roles(self, *roles):
self.roles = [role for role in self.roles if role not in roles]
def has_role(self, role):
return True if role in self.roles else False
def get_id(self):
return self.id
def __repr__(self):
return '<User {}:{}>'.format(self.id, self.username)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
