class ArtistDisc(db.Model):
id = db.Column(db.Integer, primary_key=True)
artist_id = db.Column(db.Integer, db.ForeignKey('artist.id'))
disc_id = db.Column(db.Integer, db.ForeignKey('disc.id'))
def __str__(self):
return f"<ArtistCDs: {self.id} {self.artist_id} {self.cd_id}...>"
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 Transaction(db.Model):
__tablename__ = "transaction"
id = db.Column(db.Integer, primary_key=True)
donor_id = db.Column(db.Integer, db.ForeignKey('user.id'))
recipient_id = db.Column(db.Integer, db.ForeignKey('user.id'))
project_id = db.Column(db.Integer, db.ForeignKey('project.id'))
donation = db.Column(db.Float, nullable=False)
def __repr__(self):
return '<User %r>' % self.username
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 Rented(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date)
disc_id = db.Column(db.Integer, db.ForeignKey('disc.id'))
def __str__(self):
return f"<Rented: {self.id}...>"
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 User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, index=True)
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
def __repr__(self):
return '<User %r>' % self.username
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 Message(db.Model):
__tablename__ = "message"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
is_sender = db.Column(db.Boolean, nullable=False)
other_id = db.Column(db.Integer, nullable=False)
time = db.Column(db.DateTime, nullable=False)
body = db.Column(db.String(120), nullable=False)
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 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')
def reference_col(tablename, nullable=False, pk_name='id', **kwargs):
"""Column that adds primary key foreign key reference.
Usage: ::
category_id = reference_col('category')
category = relationship('Category', backref='categories')
"""
return db.Column(db.ForeignKey('{0}.{1}'.format(tablename, pk_name)),
nullable=nullable, **kwargs)
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)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
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 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 Owner(db.Model):
__tablename__ = 'owners'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
pup_id = db.Column(db.Integer, db.ForeignKey('puppies.id'))
def __init__(self, name, pup_id):
self.name = name
self.pup_id = pup_id
def __repr__(self):
return f'{self.name}'
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 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 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 Items(db.Model):
__tablename__ = 'items'
id = db.Column('id', db.Integer, primary_key=True)
name = db.Column(db.Unicode(50))
brand = db.Column(db.Unicode(30))
size = db.Column(db.Unicode(4))
colour = db.Column(db.Unicode(10))
cond = db.Column(db.Unicode(15))
gender = db.Column(db.Unicode(6))
info = db.Column(db.Unicode(90))
price = db.Column(db.Integer)
contact = db.Column(db.Unicode(50))
imageName = db.Column(db.Unicode(100))
imageData = db.Column(db.LargeBinary)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
@property
def b64_image_data(self):
return b64encode(self.imageData).decode('utf-8')
def __repr__(self):
return '<Items: %r>' % 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 User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
username = db.Column(db.UnicodeText(64), index=True)
from flask_security import RoleMixin, UserMixin, SQLAlchemySessionUserDatastore
from {{cookiecutter.project_core_dir}}.extensions import db
role_users = db.Table(
'role_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role _id', db.Integer(), db.ForeignKey('role.id'))
)
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))
def __str__(self):
return self.name
def __hash__(self):
return hash(self.name)
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())
from sqlalchemy.ext.associationproxy import association_proxy
# from {{cookiecutter.app_name}}.utils import uuid
def _role_find_or_create(r):
role = Role.query.filter_by(name=r).first()
if not(role):
role = Role(name=r)
role.insert()
return role
user_role_table = db.Table('user_roles',
db.Column(
'user_id', db.VARCHAR(36),
db.ForeignKey('users.id')),
db.Column(
'role_id', db.VARCHAR(36),
db.ForeignKey('roles.id'))
)
role_abilities_table = db.Table('role_abilities',
db.Column(
'role_id', db.VARCHAR(36),
db.ForeignKey('roles.id')),
db.Column(
'ability_id', db.VARCHAR(36),
db.ForeignKey('abilities.id'))
)
from {{cookiecutter.app_name}}.database import db
tags_posts = db.Table('tags_posts',
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id')),
db.Column('post_id', db.Integer, db.ForeignKey('posts.id'))
)
from flask_login import UserMixin
from {{ cookiecutter.project_name }}.external import db
roles_users = db.Table('roles_users',
db.Column('role_id', db.ForeignKey('role.id',
ondelete='CASCADE'),
nullable=False),
db.Column('user_id', db.ForeignKey('user.id',
ondelete='CASCADE'),
nullable=False),
db.UniqueConstraint('role_id', 'user_id',
name='ux_role_user'))
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'))
class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
