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)
示例#2
0
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}>"
示例#3
0
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")
示例#4
0
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 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}>"
示例#6
0
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}>"
示例#7
0
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")
示例#8
0
class Movie(db.Model):
    """
    Model form movie details
    """
    __tablename__ = "movies"

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(120), nullable=False)
    release_date = db.Column(db.DateTime)
    cinemas = db.relationship("Cinema",
                              secondary='shows',
                              back_populates="movies")
示例#9
0
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")
示例#10
0
class City(db.Model):
    """
    List of cities  which are playing movies
    """
    __tablename__ = "cities"

    id = db.Column(db.Integer, primary_key=True)
    city_name = db.Column(db.String(80), nullable=False)
    cinemas = db.relationship("Cinema")

    @hybrid_property
    def movies(self):
        return list(chain(*[cinema.movies for cinema in self.cinemas]))
示例#11
0
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)
    username = db.Column(db.String(), nullable=False, unique=True)
    name = db.Column(db.String())
    profile_image = db.Column(db.String())
    timezone = db.Column(db.Integer, nullable=False, default=0)
    has_reminders = db.Column(db.Boolean, nullable=False, default=False)
    reminder_time = db.Column(db.Integer, default=None)
    checklists = db.relationship("Checklist",
                                 secondary=users_checklists,
                                 back_populates="users")
    owned_checklists = db.relationship("Checklist",
                                       backref="owner",
                                       cascade="all, delete-orphan")
    items = db.relationship("Item", backref="assigned_to")

    def __repr__(self):
        return f"<User {self.email}>"
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 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}>"
示例#14
0
class User(db.Model):
    """
    User model for storing user data
    """
    __tablename__ = "users"

    id = db.Column(db.Integer, primary_key=True)
    phone_number = db.Column(db.String(10), unique=True, nullable=False)
    password = db.Column(db.String(128), nullable=False)
    tickets = db.relationship("Ticket")

    @classmethod
    def check_password(cls, password, _hash):
        return django_pbkdf2_sha256.verify(password, _hash)

    def pre_commit_setup(self):
        """
        This method generates the required fields either from available
        information else automatic fields are generated.
        """
        self.password = django_pbkdf2_sha256.hash(self.password)
示例#15
0
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)
示例#16
0
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
       }
示例#17
0
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
示例#18
0
class Client(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)
    feature_requests = db.relationship("FeatureRequest",
                                       back_populates="client")

    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return '<Client %s>' % self.name

    def jsonify(self):
        """Return JSON representation of the object"""
        return {
            'id':
            self.id,
            'name':
            self.name,
            'feature_requests': [
                feature_request.jsonify()
                for feature_request in self.feature_requests
            ]
        }