class Listing(db.Model):
# Columns
type = db.Column(
db.Enum(ListingTypes),
nullable=False,
primary_key=True
)
user_id = db.Column(
db.Integer,
db.ForeignKey('user.id'),
nullable=False,
primary_key=True
)
message_id = db.Column(
db.Integer,
db.ForeignKey('message.id'),
nullable=False,
primary_key=True
)
# Relations
user = db.relationship(
"User",
foreign_keys=user_id,
backref='listings'
)
message = db.relationship(
"Message",
foreign_keys=message_id,
backref='listings'
)
class User(BaseMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(80), unique=True, nullable=False)
active = db.Column(db.Boolean, default=True)
_password_hash = db.Column(db.String(), nullable=False)
# Relationships
todos = db.relationship('Todo', backref='user', lazy='dynamic')
todo_lists = db.relationship('TodoList', backref='user', lazy='dynamic')
@property
def is_active(self):
return self.active
@property
def is_authenticated(self):
return self.authenticated
@property
def is_anonymous(self):
return False
@property
def password(self):
return self._password_hash.encode('UTF-8')
@password.setter
def password(self, password):
self._password_hash = bcrypt.hashpw(password.encode('UTF-8'),
bcrypt.gensalt())
def verify_password(self, password):
return bcrypt.hashpw(password.encode('UTF-8'),
self.password) == self.password
def get_id(self):
return self.id
@staticmethod
def authenticate(username, password):
if username and password:
user = User.query.filter_by(username=username).first()
if user is None:
user = DummyUser()
if user.verify_password(password):
return user
@staticmethod
def identity(payload):
username = payload['identity']
return User.query.filter_by(username=username).first()
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password = password
def __repr__(self):
return "<User: {}>".format(self.username)
class WaitingList(db.Model):
waiting_id = db.Column(db.Integer, primary_key=True)
approval = db.Column(db.Boolean, nullable=True)
method = db.Column(db.String)
date = db.Column(db.DateTime, default=datetime.datetime.today)
request_Date = db.Column(db.DateTime, nullable=True)
borrower = db.Column(db.Integer, db.ForeignKey('user.id'))
price = db.Column(db.Integer, nullable=True)
price_rate = db.Column(db.Integer, nullable=True)
owner_shelf_id = db.Column(db.Integer,
db.ForeignKey('bookshelf.bookshelf_id'))
bookid = db.Column(db.Integer, db.ForeignKey('books.book_id'))
user = db.relationship('User', backref='waitingUsers')
bookshelf = db.relationship('Bookshelf', backref='waitingBookshelf')
def __init__(self,
borrower='',
owner_shelf_id='',
price='',
price_rate='',
approval='',
method='',
bookid='',
request_Date=''):
self.borrower = borrower
self.owner_shelf_id = owner_shelf_id
self.approval = approval
self.price_rate = price_rate
self.price = price
self.bookid = bookid
self.method = method
self.request_Date = request_Date
class Tournament(db.Model):
__tablename__ = 'tournaments'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
tournament_title = db.Column(db.String(300), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
is_completed = db.Column(db.Boolean, default=False)
players = db.relationship('TournamentPlayers',
backref='players',
lazy='dynamic')
matches = db.relationship('Matches', backref='match_round', lazy='dynamic')
def __repr__(self):
return '<Tournament {}>'.format(self.tournament_title)
# sets the tournament completation status. Should pretty much be true as false is default
def set_isCompleted(self, isCompleted):
self.is_completed = isCompleted
def to_dict(self):
return dict(id=self.id,
userID=self.user_id,
tournament_title=self.tournament_title,
players=[player.to_dict() for player in self.players],
match=[match.to_dict() for match in self.matches],
tournamentCompleted=self.is_completed)
class Fund(db.Model):
__tablename__ = 'fund'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False, unique=True)
date = db.Column(db.DateTime, default=datetime.now(), nullable=False)
# Establish One-to-Many relationship
committments = db.relationship(
'Committment',
backref='fund',
lazy='dynamic'
)
# Establish Many-to-Many relationship
investments = db.relationship(
'Investment',
secondary=FundInvestments,
backref=db.backref('fund', lazy='dynamic')
)
def __init__(self, name):
self.name = name
def to_json(self):
return {
'id': self.id,
'name': self.name,
'date': self.date.strftime('%Y-%m-%d T%H:%M:%S.%f'),
'committments': [c.to_json() for c in self.committments],
}
class BorrowsAssociation(db.Model):
__tablename__ = 'borrows'
borrowed = db.Column(db.Integer, primary_key=True)
borrower = db.Column(db.Integer, db.ForeignKey('user.id'))
owner_shelf_id = db.Column(db.Integer,
db.ForeignKey('bookshelf.bookshelf_id'))
bookid = db.Column(db.Integer, db.ForeignKey('books.book_id'))
status = db.Column(db.String)
startDate = db.Column(db.DateTime)
returnDate = db.Column(db.DateTime)
verification = db.Column(db.Boolean)
user = db.relationship('User', backref='borrowBookshelfs')
bookshelf = db.relationship('Bookshelf', backref='borrowUsers')
def __init__(self,
borrower='',
owner_shelf_id='',
status='',
bookid='',
verification='',
startDate='',
returnDate=''):
self.borrower = borrower
self.owner_shelf_id = owner_shelf_id
self.status = status
self.bookid = bookid
self.verification = verification
self.startDate = startDate
self.returnDate = returnDate
class Client(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True)
id_phone = db.Column(db.Integer, db.ForeignKey('phone.id'), nullable=True)
email = db.Column(db.String(50), unique=True)
created = db.Column(db.DateTime)
# cria uma propriedade
# (não faz parte do banco de dados)
records = db.relationship(
'Record',
# backref='client': um jeito simples de declarar também uma nova propriedade na classe Record
# haverá a propriedade record.client para Record
backref='client',
# Indica quando os dados serão carregados do banco de dados
# o lazy='dynamic' retorna um objeto query que pode ser refinado antes de carregar items.
lazy='dynamic')
# cria uma propriedade que expressa um relacionamento um-para-um (uselist=False)
phone = db.relationship('Phone', backref='client', uselist=False)
groups = db.relationship('Group',
secondary=clients_groups,
backref=db.backref('members', lazy='dynamic'))
def __init__(self, username, email):
self.username = username
self.email = email
self.created = datetime.now()
class ContainsAssociation(db.Model):
__tablename__ = 'contains'
contains_id = db.Column(db.Integer, primary_key=True)
quantity = db.Column(db.Integer)
availability = db.Column(db.String(3))
methods = db.Column(db.String(50))
price = db.Column(db.Integer)
date = db.Column(db.DateTime, default=datetime.datetime.today)
shelf_id = db.Column(db.Integer, db.ForeignKey('bookshelf.bookshelf_id'))
book_id = db.Column(db.Integer, db.ForeignKey('books.book_id'))
rateBooks = db.relationship('BookRateAssociation',
backref='books_rateBooks')
commentBooks = db.relationship('BookCommentAssociation',
backref='books_commentBooks')
bookshelfcontain = db.relationship('Bookshelf', backref='containingbooks')
containsbooks = db.relationship('Books', backref='booksBookshelf')
def __init__(self,
shelf_id='',
book_id='',
quantity='',
availability='',
methods='',
price=''):
self.shelf_id = shelf_id
self.book_id = book_id
self.quantity = quantity
self.methods = methods
self.price = price
self.availability = availability
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
gardens = db.relationship('Garden', secondary=ownership, lazy='dynamic',
backref=db.backref('owners', lazy='dynamic'))
sensors = db.relationship('Sensor', backref='owner', lazy='dynamic')
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 generate_auth_token(self, expiration=600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # Valid token but expired
except BadSignature:
return None # Invalid token
user = User.query.get(data['id'])
return user
def __repr__(self):
return '<User {}>'.format(self.username)
class Department(db.Model):
__tablename__ = 'departments'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50))
code = db.Column(db.String(3))
school_id = db.Column(db.Integer, db.ForeignKey('schools.id'))
students = db.relationship('Student', backref='department')
courses = db.relationship('Course', backref='department')
lecturers = db.relationship('Lecturer', backref='department')
hod = db.relationship('HOD', backref='department', uselist=False)
def __init__(self, name=None, code=None, school_code=None):
self.name = name
self.code = code
self.school = School.query.filter_by(code=school_code).first()
@staticmethod
def exists(department_code):
return Department.query.filter_by(code=department_code).count() > 0
@property
def to_dict(self):
json_department = {
'code': self.code,
'fullname': self.name,
'school_code': self.school.code,
'school_fullname': self.school.name
}
return json_department
def save(self):
db.session.add(self)
db.session.commit()
class InterestAssociation(db.Model):
__tablename__ = 'hasInterest'
interestId = db.Column(db.Integer, primary_key=True)
user_Id = db.Column(db.Integer, db.ForeignKey('user.id'))
genreId = db.Column(db.Integer, db.ForeignKey('genre.id_genre'))
user = db.relationship('User', backref='Interestuser')
genre = db.relationship('Genre', backref='Interestgenre')
class Post(db.AlchemyBase):
__tablename__ = "post"
id = db.Column(db.Integer, primary_key=True)
entity_id = db.Column(db.Integer, nullable=False, index=True, unique=True)
user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False)
section_id = db.Column(db.Integer,
db.ForeignKey(Section.id),
nullable=False,
index=True)
title = db.Column(db.String(255), nullable=False)
text = db.Column(db.Text)
pin_teaser = db.Column(db.Text)
is_pinned = db.Column(db.Boolean,
nullable=False,
default=False,
index=True)
is_deleted = db.Column(db.Boolean,
nullable=False,
default=False,
index=True)
is_moderated = db.Column(db.Boolean, nullable=False, default=False)
is_legacy = db.Column(db.Boolean,
nullable=False,
default=False,
index=True)
original_title = db.Column(db.String(255))
original_text = db.Column(db.Text)
moderation_notes = db.Column(db.Text)
created = db.Column(db.DateTime, default=datetime.utcnow, index=True)
modified = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
user = db.relationship(User)
section = db.relationship(Section)
class User(db.Model, UserMixin):
# Columns
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False)
password = db.Column(db.Text, nullable=False)
# Relations
inbox = db.relationship(
"Message",
secondary=Listing.__table__,
primaryjoin=
f"and_(Listing.type=='{ListingTypes.inbox.name}', Listing.user_id==User.id)",
order_by="desc(Message.created_at)")
outbox = db.relationship(
"Message",
secondary=Listing.__table__,
primaryjoin=
f"and_(Listing.type=='{ListingTypes.outbox.name}', Listing.user_id==User.id)",
order_by="desc(Message.created_at)")
# Methods
""" Hash a password and set it as the user's password """
def set_password(self, password):
self.password = generate_password_hash(password, method='sha256')
""" Check if password matched the hashed password """
def check_password(self, password):
return check_password_hash(self.password, password)
class Applicant(db.Model):
__tablename__ = 'applicants'
# The name of the column is the name you assign it to
id = Column(Integer, primary_key=True)
email = Column(String(100), unique=True, nullable=False)
username = Column(String(100), default='Anonymous Giraffe')
bio = Column(String(250))
first_name = Column(String(80))
last_name = Column(String(80))
created_at = Column(DateTime(timezone=True),
nullable=False,
default=datetime.now())
# One to Many Relationship:
messages = db.relationship('Message', backref='applicant', lazy=True)
# Many to Many Relationship:
skills = db.relationship('Skill',
secondary='applicant_skills',
lazy='subquery')
values = db.relationship('Value',
secondary='applicant_values',
lazy='subquery')
class User(db.Model):
""" Contains information about the user """
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(100), unique=True, nullable=False)
mobile = db.Column(db.String(15), unique=True, nullable=True)
firstname = db.Column(db.String(20), nullable=False)
lastname = db.Column(db.String(20), nullable=False)
password = db.Column(db.String(128), nullable=False)
created = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
recipes = db.relationship("Recipe", backref="creator", lazy="dynamic")
recipe_categories = db.relationship("RecipeCategory",
backref="creator",
lazy="dynamic")
def __init__(self, email, fname, lname, password, mobile=None):
""" User initializer """
self.email = email
self.firstname = fname
self.lastname = lname
self.set_password(password)
self.mobile = mobile
def set_password(self, password):
""" Sets user password to a new password"""
self.password = generate_password_hash(password,
method="pbkdf2:sha256")
def verify_password(self, password):
"""
Checks if user supplied a correct password
:param password: Password user has provided
:return: True if password is correct false otherwise
"""
return check_password_hash(self.password, password)
def save_user(self):
""" saves the current user to the database"""
db.session.add(self)
db.session.commit()
@property
def user_details(self):
""" Returns the user json representation """
user_details = {
"id": self.id,
"firstname": self.firstname,
"lastname": self.lastname,
"email": self.email,
"mobile": self.mobile,
"url": url_for("get_user", id=self.id, _external=True)
}
return user_details
def __repr__(self):
""" User object representation """
return f"<User {self.id} {self.firstname} {self.lastname}>"
class Facturas(db.Model):
FacturaID = db.Column(db.Integer, primary_key=True)
FechaPago = db.Column(db.DateTime, nullable=False)
MetodoPago = db.Column(db.String(), nullable=False)
Descripcion = db.Column(db.String(), nullable=False)
ClienteID = db.Column(db.Integer(),db.ForeignKey('usuarios.ClienteID'))
cliente_id = db.relationship('Usuarios',foreign_keys=ClienteID, backref='Facturas')
ProductoID = db.Column(db.Integer(),db.ForeignKey('productos.ProductoID'))
producto_id = db.relationship('Productos',foreign_keys=ProductoID, backref='Facturas')
class User(UserMixin, db.Model):
__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(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
posts = db.relationship('Entry', backref='author', lazy='dynamic')
location_posts = db.relationship('Location',
backref='author',
lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def serialize(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'password_hash': 'private!',
'about_me': self.about_me,
'last_seen': self.last_seen
}
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 avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
app.config['SECRET_KEY'],
algorithm='HS256')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return db.session.query(User).get(id)
class Business(db.Model):
""""""
__tablename__ = 'businesses'
id = db.Column(db.Integer, primary_key=True, index=True)
name = db.Column(db.String(100), nullable=False, unique=True)
description = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
location_id = db.Column(db.Integer, db.ForeignKey('locations.id'))
categories = db.relationship('Category',
secondary=business_category,
lazy='subquery',
backref=db.backref('businesses', lazy=True))
reviews = db.relationship('Review', backref='business', lazy=True)
photo = db.Column(db.String(200))
created_at = db.Column(db.DateTime, default=datetime.utcnow())
updated_at = db.Column(db.DateTime, default=datetime.utcnow())
def create(self):
db.session.add(self)
db.session.commit()
def update(self):
db.session.commit()
business = Business.query.get(self.id)
result = {
'message': 'Business updated successfully.',
'code': 200,
'business': Business.get_business_details(business)
}
return result
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def get_business(id):
business = Business.query.get(int(id))
return business
@staticmethod
def get_business_details(business):
categories = [
Category.get_categories_details(c) for c in business.categories
]
return {'id': business.id, 'name':business.name, 'description': business.description, 'userId':business.user_id, \
'locationId':business.location_id, 'categories':categories, 'photo':business.photo}
@staticmethod
def get_businesses():
businesses = Business.query.all()
return businesses
def __repr__(self):
""""""
return '<Business : {0} >'.format(self.name)
class Genre(db.Model):
__tablename__ = 'genre'
id_genre = db.Column(db.Integer, primary_key=True)
genre_name = db.Column(db.String, nullable=False, unique=True)
genreBooks = db.relationship('HasGenreAssociation', backref='genres_books')
genreInterest = db.relationship('InterestAssociation',
backref='genre_interest')
def __init__(self, genre_name=''):
self.genre_name = genre_name
class User(db.Model, UserMixin):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, unique=True)
username = db.Column(db.String(100), index=True, nullable=False)
email = db.Column(db.String(100), index=True, nullable=False)
password = db.Column(db.String(100), index=True, nullable=False)
list = db.relationship('List', backref='user', lazy=True)
cat = db.relationship('Category', backref='user', lazy=True)
def __repr__(self):
return f"<User(name='{self.username}')>"
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
image_url = db.Column(db.String(255))
price = db.Column(db.DECIMAL)
title = db.Column(db.String(255))
description = db.Column(db.Text, default='')
ingredients = db.relationship('Flower', secondary=product_flower, lazy='subquery',
backref=db.backref('product', lazy=True))
categories = db.relationship('Category', secondary=product_category, lazy='subquery',
backref=db.backref('products', lazy=True))
class HasGenreAssociation(db.Model):
__tablename__ = 'hasGenre'
genre_book_id = db.Column(db.Integer, primary_key=True)
genreId = db.Column(db.Integer, db.ForeignKey('genre.id_genre'))
bookId = db.Column(db.Integer, db.ForeignKey('books.book_id'))
books = db.relationship('Books', backref='booksGenre')
genre = db.relationship('Genre', backref='bookHasGenre')
def __init__(self, bookId='', genreId=''):
self.bookId = bookId
self.genreId = genreId
class Section(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(70), index=True)
description = db.Column(db.String(140))
garden_id = db.Column(db.Integer, db.ForeignKey('garden.id'))
sensors = db.relationship('Sensor', backref='section', lazy='dynamic')
schedule = db.relationship('Schedule', uselist=False, backref ='section')
def __repr__(self):
return '<Section {}>'.format(self.name)
class WrittenByAssociation(db.Model):
__tablename__ = 'writtenBy'
book_id = db.Column(db.Integer,
db.ForeignKey('books.book_id'),
primary_key=True)
author_id = db.Column(db.Integer, db.ForeignKey('author.author_id'))
author = db.relationship('Author', backref='author_writtenby')
books = db.relationship('Books', backref='booksAuthor_writtenby')
def __init__(self, author_id='', book_id=''):
self.author_id = author_id
self.book_id = book_id
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(100), unique=True, nullable=False)
password = db.Column(db.String(20), nullable=False)
last_seen = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
last_activity = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
posts = db.relationship('Post', backref='author', lazy=True)
likes = db.relationship('Like', backref='likedby', lazy=True)
def __repr__(self):
return f"User: ('{self.username}', last_seen: '{self.last_seen}')"
class TodoList(db.Model):
__tablename__ = 'todolist'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80))
todos = db.relationship("Todo", cascade="all,delete", back_populates="todolist")
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = db.relationship("User", back_populates="todolists")
def __init__(self, user, title):
self.user = user
self.title = title
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
completed = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)
planned_complete_date = db.Column(db.DateTime)
completed_at = db.Column(db.DateTime)
project_id = db.Column(db.Integer, db.ForeignKey('project.id'), nullable=False)
comments = db.relationship('Comment', backref='task', lazy='dynamic')
assignees = db.relationship('User',
secondary=assignees_for_tasks,
backref=db.backref('tasks', lazy='dynamic'),
lazy='dynamic'
)
def save(self):
db.session.add(self)
def delete(self):
db.session.delete(self)
@staticmethod
def get_all():
return Task.query.all()
def add_assignee(self, assignee):
self.assignees.append(assignee)
db.session.add(self)
def remove_assignee(self, assignee):
self.assignees.remove(assignee)
db.session.add(self)
def update_completed_state(self, old_task_completed):
print("Self completed")
print(self.completed)
print("OG task completed")
print(old_task_completed)
if self.completed != old_task_completed:
print("Got to first if")
if self.completed:
print("Got to second if")
self.completed_at = datetime.utcnow()
else:
self.completed_at = None
return self
def __repr__(self):
return f'<Task {self.name} | Created at {self.created_at} | {self.completed} | Completed at {self.completed_at}>'
class TrackOut(db.Model):
'''
Database Generated Fields
'''
id = db.Column(db.Integer, primary_key=True)
track_id = db.Column(db.Integer,
db.ForeignKey('track.uuid', ondelete='CASCADE'))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
uuid = db.Column(db.String, default=generate_uuid)
'''
Configurable Fields
'''
user_id = db.Column(db.Integer)
name = db.Column(db.String(1000))
type = db.Column(db.String(50))
settings = db.Column(db.String(1000))
eq = db.relationship("Equalizer",
backref=db.backref("eq", passive_deletes=True),
lazy='subquery',
uselist=False)
de = db.relationship("Deesser",
backref=db.backref("de", passive_deletes=True),
lazy='subquery',
uselist=False)
co = db.relationship("Compressor",
backref=db.backref("co", passive_deletes=True),
lazy='subquery',
uselist=False)
re = db.relationship("Reverb",
backref=db.backref("re", passive_deletes=True),
lazy='subquery',
uselist=False)
'''
Wav File Representation
'''
path = db.Column(db.String(1000))
file_hash = db.Column(db.LargeBinary, unique=True)
def to_dict(self):
trackout = {
"id": self.id,
"uuid": self.uuid,
"user_id": self.user_id,
"track_id": self.track_id,
"created_at": self.created_at,
"name": self.name,
"type": self.type,
"path": self.path,
"settings": self.settings
}
return trackout
class Movies(db.Model):
__tablename__ = 'title_basics'
id = db.Column('tconst', db.String, primary_key=True)
type = db.Column('titleType', db.String)
title = db.Column('primaryTitle', db.String)
originalTitle = db.Column(db.String)
isAdult = db.Column(db.Integer)
startYear = db.Column(db.Integer)
endYear = db.Column(db.Integer, nullable=True)
runtimeMinutes = db.Column(db.Integer)
genres = db.Column(db.String)
rating = db.relationship("Rating", uselist=False, backref="title_basics")
poster = db.relationship("MoviePoster", backref="title_basics")
class Wishlist(db.Model):
__tablename__ = "wishlist"
wishlist_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
shelf_id = db.Column(db.Integer, db.ForeignKey('bookshelf.bookshelf_id'))
bookId = db.Column(db.Integer)
user = db.relationship('User', backref='wishlist_user')
bookshelf = db.relationship('Bookshelf', backref='bookshelf_wishlist')
def __init__(self, user_id='', shelf_id='', bookId=''):
self.user_id = user_id
self.shelf_id = shelf_id
self.bookId = bookId
