class Move(db.Model):
__tablename__ = "moves"
move_id = db.Column(db.Integer, primary_key=True)
move_name = db.Column(db.String(), nullable=False)
def __repr__(self):
return f"<(#{self.move_id} {self.move_name})>"
@staticmethod
def get_move_data(move_id):
"""
Requests move data from pokeapi and returns the data as JSON
"""
return json.loads(
requests.get(f"https://pokeapi.co/api/v2/move/{move_id}").text)
@staticmethod
def get_move_list(pokemon_data, move_set):
"""
Returns a list of learnable moves since a pokemon can't know the same move twice
"""
learned_moves = {move.move.move_name for move in move_set}
return [[
move["move"]["name"],
move["move"]["url"].replace("https://pokeapi.co/api/v2/move/",
"").replace("/", "")
] for move in pokemon_data["moves"]
if move["move"]["name"] not in learned_moves]
class Base(db.Model):
__abstract__ = True
created_on = db.Column(db.DateTime, default=db.func.now())
updated_on = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
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 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 InvalidatedToken(db.Model):
token = db.Column(db.String(120), primary_key=True)
invalidated_date = db.Column(db.DateTime(timezone=True),
server_default=func.now())
def __init__(self, token):
self.token = token
def __repr__(self):
return '<InvalidatedToken %s, %s>' % (self.token,
str(self.invalidated_date))
def jsonify(self):
"""Return JSON representation of the object"""
return {
'token': self.token,
'invalidated_date': str(self.invalidated_date)
}
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 User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(), nullable=False, unique=True)
password = db.Column(db.String(), nullable=False)
country = db.Column(db.String(2), nullable=True)
display_name = db.Column(db.String(30), nullable=True)
href = db.Column(db.String(),
nullable=False,
default="https://api.spotify.com/users/<id>")
product = db.Column(db.String(20), nullable=False, default="free")
object_type = db.Column(db.String(20), nullable=False, default="user")
uri = db.Column(db.String(), nullable=False, default="spotify:user:<id>")
track_ratings = db.relationship("Track_Rating", backref="user")
admin = db.Column(db.Boolean, nullable=False, default=False)
def __repr__(self):
return f"<User {self.email}>"
class User(db.Model, UserMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(), nullable=False, unique=True)
username = db.Column(db.String(30), nullable=False, unique=True)
password = db.Column(db.String(), nullable=False)
teams = db.relationship("Team",
backref="owner",
cascade="all, delete-orphan")
def __repr__(self):
return f"<User {self.email}>"
@classmethod
def check_unique_email(cls, email):
"""
Checks uniqueness of an email address, returns True if unique
"""
if User.query.filter_by(email=email).first():
return False
return True
@classmethod
def check_unique_username(cls, username):
"""
Checks uniqueness of a username, returns True if unique
"""
if User.query.filter_by(username=username).first():
return False
return True
def check_password(self, password):
"""
Checks that password data entered in a form matches the password has in the database
"""
return bcrypt.check_password_hash(self.password, password)
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 RevokedTokenModel(db.Model):
"""
Revoked Token Model Class
"""
__tablename__ = 'revoked_tokens'
__bind_key__ = 'users'
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(120))
"""
Save Token in DB
"""
def add(self):
db.session.add(self)
db.session.commit()
"""
Checking that token is blacklisted
"""
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti=jti).first()
return bool(query)
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
class Artist(db.Model):
__tablename__ = "artists"
id = db.Column(db.Integer, primary_key=True)
albums = db.relationship("Album", back_populates="artist")
followers = db.Column(db.Integer, nullable=False, default=0)
genre = db.Column(db.String(20), nullable=False)
href = db.Column(db.String(),
nullable=False,
default="https://api.spotify.com/artists/<id>")
name = db.Column(db.String(), nullable=False)
popularity = db.Column(db.Integer, nullable=False, default=0)
object_type = db.Column(db.String(20), nullable=False, default="artist")
tracks = db.relationship("Track", back_populates="artist")
uri = db.Column(db.String(), nullable=False, default="spotify:artist:<id>")
def __repr__(self):
return f"<Artist {self.name}>"
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")
