class Review(db.Model):
__tablename__ = "reviews"
id = db.Column(db.Integer, primary_key=True)
review_title = db.Column(db.String)
review_description = db.Column(db.String)
review_score = db.Column(db.Integer, nullable=False)
restaurant_id = db.Column(db.Integer,
db.ForeignKey("restaurants.id"),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
def __init__(self, review_title, review_description, review_score, user_id,
restaurant_id):
self.review_title = review_title
self.review_description = review_description
self.review_score = review_score
self.user_id = user_id
self.restaurant_id = restaurant_id
def __repr__(self):
return "<id {}>".format(self.id)
def serialize(self):
return ReviewSchema().dump(self)
def update(self, req):
self.review_title = assign_req_values(req, "review_title",
self.review_title)
self.review_description = assign_req_values(req, "review_description",
self.review_description)
self.review_score = assign_req_values(req, "review_score",
self.review_score)
return db.session.commit()
class Track(db.Model):
__tablename__ = "tracks"
id = db.Column(db.Integer, primary_key=True)
album_id = db.Column(db.Integer,
db.ForeignKey("albums.id"),
nullable=False)
album = db.relationship("Album", back_populates="tracks")
artist_id = db.Column(db.Integer,
db.ForeignKey("artists.id"),
nullable=False)
artist = db.relationship("Artist", back_populates="tracks")
disc_number = db.Column(db.Integer, nullable=False, default=1)
duration_ms = db.Column(db.Integer, nullable=False)
explicit = db.Column(db.Boolean, nullable=False, default=False)
href = db.Column(db.String(),
nullable=False,
default="https://api.spotify.com/tracks/<id>")
name = db.Column(db.String(), nullable=False)
popularity = db.Column(db.Integer, nullable=False, default=0)
preview_url = db.Column(db.String(),
nullable=False,
default="https://p.scdn.co/mp3-preview/<id>")
track_number = db.Column(db.Integer, nullable=False)
object_type = db.Column(db.String(20), nullable=False, default="track")
uri = db.Column(db.String(), nullable=False, default="spotify:track:<id>")
is_local = db.Column(db.Boolean, nullable=False, default=False)
class Ticket(db.Model):
"""
Model for tickets
"""
__tablename__ = "tickets"
id = db.Column(db.Integer, primary_key=True)
transaction_id = db.Column(db.String(128), nullable=False)
movie = db.Column(db.Integer, db.ForeignKey('movies.id'), nullable=False)
cinema = db.Column(db.Integer, db.ForeignKey('cinemas.id'), nullable=False)
show_time = db.Column(db.String(8), nullable=False)
no_of_seats = db.Column(db.Integer, nullable=False)
ticket_date = db.Column(db.Date, nullable=False)
transaction_date = db.Column(db.Date,
nullable=False,
default=datetime.utcnow)
user = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
def pre_commit_setup(self):
"""
This method is used to generate uuids for each ticket transaction.
"""
self.transaction_id = uuid.uuid1()
class Pokemon_Moves(db.Model):
__tablename__ = "pokemon_moves"
team_pokemon_id = db.Column(db.Integer, db.ForeignKey("teams_pokemon.id"), primary_key=True)
pokeapi_id = db.Column(db.Integer, db.ForeignKey("pokemon.pokeapi_id"), primary_key=True)
pokemon_move_index = db.Column(db.Integer, primary_key=True)
move_id = db.Column(db.Integer, db.ForeignKey("moves.move_id"))
move = db.relationship("Move")
def __repr__(self):
return f"<Pokemon #{self.pokeapi_id}, Slot {self.pokemon_move_index}>"
class Show(db.Model):
__tablename__ = "shows"
movie_id = db.Column(db.Integer,
db.ForeignKey('movies.id'),
primary_key=True)
cinema_id = db.Column(db.Integer,
db.ForeignKey('cinemas.id'),
primary_key=True)
show_times = db.Column(db.String(8), nullable=False, primary_key=True)
show_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
no_of_seats = db.Column('no_of_seats', db.Integer, nullable=False)
cinema = db.relationship("Cinema", backref="shows")
class Item(db.Model):
__tablename__ = "items"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(), nullable=False)
status = db.Column(db.Boolean, nullable=False, default=False)
index = db.Column(db.Integer, nullable=False, default=1)
checklist_id = db.Column(db.Integer,
db.ForeignKey("checklists.id"),
nullable=False)
assigned_id = db.Column(db.Integer, db.ForeignKey("users.id"))
completion_date = db.Column(db.DateTime(), nullable=True)
class Track_Rating(db.Model):
__tablename__ = "track_ratings"
user_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
primary_key=True)
track_id = db.Column(db.Integer,
db.ForeignKey("tracks.id"),
primary_key=True)
rating = db.Column(db.Integer, nullable=False)
track = db.relationship("Track")
def __repr__(self):
return f"<Track_Rating User: {self.user_id}, Track: {self.track_id}>"
class Album(db.Model):
__tablename__ = "albums"
id = db.Column(db.Integer, primary_key=True)
album_type = db.Column(db.String(20), nullable=False, default="album")
artist_id = db.Column(db.Integer,
db.ForeignKey("artists.id"),
nullable=False)
artist = db.relationship("Artist", back_populates="albums")
copyright = db.Column(db.String(100), nullable=False)
copyright_type = db.Column(db.String(1), nullable=False)
genre = db.Column(db.String(20), nullable=False)
href = db.Column(db.String(),
nullable=False,
default="https://api.spotify.com/albums/<id>")
label = db.Column(db.String(50), nullable=False)
name = db.Column(db.String(), nullable=False)
release_date = db.Column(db.Integer, nullable=False)
release_date_precision = db.Column(db.String(5),
nullable=False,
default="year")
object_type = db.Column(db.String(20), nullable=False, default="album")
tracks = db.relationship("Track", back_populates="album")
uri = db.Column(db.String(), nullable=False, default="spotify:album:<id>")
def __repr__(self):
return f"<Album {self.name}>"
class Teams_Pokemon(db.Model):
__tablename__ = "teams_pokemon"
id = db.Column(db.Integer,
db.Sequence("teams_pokemon_id_seq"),
unique=True,
autoincrement=True)
team_id = db.Column(db.Integer,
db.ForeignKey("teams.id"),
primary_key=True)
team_index = db.Column(db.Integer, primary_key=True)
pokeapi_id = db.Column(db.Integer, db.ForeignKey("pokemon.pokeapi_id"))
pokemon = db.relationship("Pokemon")
pokemon_moves = db.relationship("Pokemon_Moves",
cascade="all, delete-orphan")
def __repr__(self):
return f"<Team {self.team_id}, Slot {self.team_index}>"
class Restaurant_Item(db.Model):
__tablename__ = "restaurant_items"
__table_args__ = (db.PrimaryKeyConstraint("restaurant_id",
"menu_item_id"), )
restaurant_id = db.Column(db.Integer,
db.ForeignKey("restaurants.id"),
nullable=False)
menu_item_id = db.Column(db.Integer,
db.ForeignKey("menu_item.id"),
nullable=False)
def __init__(self, restaurant_id, menu_item_id):
self.restaurant_id = restaurant_id
self.menu_item_id = menu_item_id
def __repr__(self):
return "<id {}>".format(self.id)
class Cinema(db.Model):
"""
Model for cinemas
"""
__tablename__ = "cinemas"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
show_times = db.Column(ARRAY(db.String(8)))
city = db.Column(db.Integer, db.ForeignKey('cities.id'), nullable=False)
movies = db.relationship("Movie",
secondary='shows',
back_populates="cinemas")
class Checklist(db.Model):
__tablename__ = "checklists"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(), nullable=False)
owner_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
is_group = db.Column(db.Boolean, nullable=False, default=False)
repeat_id = db.Column(db.Integer, nullable=False, default=0)
description = db.Column(db.String())
thumbnail_image = db.Column(db.String())
users = db.relationship("User",
secondary=users_checklists,
back_populates="checklists")
items = db.relationship("Item",
backref="checklist",
cascade="all, delete-orphan")
class FeatureRequest(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable = False)
description = db.Column(db.String(120))
client_id = db.Column(db.Integer, db.ForeignKey('client.id'), nullable = False)
client = db.relationship("Client", back_populates = "feature_requests")
def __init__(self, title, description, client_id):
self.title = title
self.description = description
self.client_id = client_id
def __repr__(self):
return '<FeatureRequest %s>' % self.title
def jsonify(self):
"""Return JSON representation of the object"""
return {
'id' : self.id,
'title': self.title,
'description': self.description,
'client_id': self.client_id
}
class Team(db.Model):
__tablename__ = "teams"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
description = db.Column(db.String(2000), nullable=True)
is_private = db.Column(db.Boolean, nullable=False, default=True)
owner_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
team_pokemon = db.relationship("Teams_Pokemon", backref="team", cascade="all, delete-orphan")
def __repr__(self):
return f"<Team {self.id}: {self.name}>"
@staticmethod
def sort_team_pokemon(teams):
"""
Sorts pokemon in team.team_pokemon by team index for a list of teams
"""
if type(teams) == list:
for team in teams:
team.team_pokemon.sort(key=lambda x: x.team_index)
return teams
@staticmethod
def fill_empty_team_slots(team_list_dict):
"""
Takes a list of team dicts and fills empty pokemon slots with None
"""
for team in team_list_dict:
indices = [pokemon["team_index"] for pokemon in team["team_pokemon"]]
for i in range(6):
if i + 1 not in indices:
team["team_pokemon"].insert(i, None)
return team_list_dict
from src.main import db
# The association table for the many to many relationship between users and checklists
users_checklists = db.Table(
"users_checklists", db.Model.metadata,
db.Column("user_id", db.Integer, db.ForeignKey("users.id")),
db.Column("checklist_id", db.Integer, db.ForeignKey("checklists.id")))
