class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
username = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
deleted = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
# roles = db.relationship('Role', secondary='roles_users',
# backref=db.backref('users', lazy='dynamic'))
def gravatar(self, size=64, consider_settings=True):
parameters = {'s': str(size), 'd': 'mm'}
return "https://www.gravatar.com/avatar/" + \
hashlib.md5(self.email.lower()).hexdigest() + \
"?" + urllib.urlencode(parameters)
def __str__(self):
return self.email
class ClassificationByDimension(db.Model):
__tablename__ = "classifications_by_dimension"
topic_title = db.Column("topic_title", db.String())
topic_slug = db.Column("topic_slug", db.String())
subtopic_title = db.Column("subtopic_title", db.String())
subtopic_slug = db.Column("subtopic_slug", db.String())
subtopic_position = db.Column("subtopic_position", db.Integer())
measure_id = db.Column("measure_id", db.Integer())
measure_slug = db.Column("measure_slug", db.String())
measure_position = db.Column("measure_position", db.Integer())
measure_version_id = db.Column("measure_version_id", db.Integer())
measure_version_title = db.Column("measure_version_title", db.String())
dimension_guid = db.Column("dimension_guid", db.String())
dimension_title = db.Column("dimension_title", db.String())
dimension_position = db.Column("dimension_position", db.Integer())
classification_id = db.Column("classification_id", db.Integer())
classification_title = db.Column("classification_title", db.String())
classification_position = db.Column("classification_position",
db.Integer())
includes_parents = db.Column("includes_parents", db.Boolean())
includes_all = db.Column("includes_all", db.Boolean())
includes_unknown = db.Column("includes_unknown", db.Boolean())
__table_args__ = (PrimaryKeyConstraint(
"dimension_guid",
"classification_id",
name="classification_by_dimension_value_pk"), )
class Account(Base):
__tablename__ = "account"
username = db.Column(db.String(144), unique=True, nullable=False)
password = db.Column(db.String(144), nullable=False)
admin = db.Column(db.Boolean(), server_default="0")
hidden = db.Column(db.Boolean(), server_default="0")
events = db.relationship('Event', backref='creator')
def __init__(self, username, password):
self.username = username
self.password = password
def get_id(self):
return self.id
def is_active(self):
return True
def is_anonymous(self):
return False
def is_authenticated(self):
return True
def roles(self):
if self.username == "admin":
return ["ADMIN", "SUPERADMIN"]
elif self.admin is True:
return ["ADMIN"]
else:
return ["account"]
class Req(db.Model):
id = db.Column(db.Integer, primary_key=True)
mowing = db.Column(db.Boolean())
hedging = db.Column(db.Boolean())
fencing = db.Column(db.Boolean())
patios = db.Column(db.Boolean())
bricklaying = db.Column(db.Boolean())
jobs_id = db.Column(db.Integer, db.ForeignKey('jobs.id'), nullable=False)
class Day(db.Model):
__tablename__ = 'days'
id = db.Column(db.Integer(), primary_key=True)
date = db.Column(db.DateTime(),
default=datetime.datetime.utcnow,
nullable=False)
habit_id = db.Column(db.Integer(), db.ForeignKey('habits.id'))
user_id = db.Column(db.Integer(), db.ForeignKey('users.id'))
habit_complete = db.Column(db.Boolean())
#Parent
habit = relationship("Habit", back_populates="days")
#Child
daydescs = relationship("DayDesc",
back_populates='day',
cascade="all, delete, delete-orphan")
def __init__(self, date, habit_id, user_id, habit_complete):
self.date = date
self.habit_id = habit_id
self.user_id = user_id
self.habit_complete = habit_complete
def __repr__(self):
return f'{self.date}:{self.habit_id}:{self.habit_complete}'
class User(db.Model):
id = db.Column(UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
username = db.Column(db.String(64),
index=True,
unique=True,
nullable=False)
email = db.Column(db.String(120), index=True, unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
created = db.Column(db.DateTime(), default=datetime.now(), nullable=False)
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(
password.encode('utf-8'),
current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
def __repr__(self):
return '<User {}>'.format(self.id)
def to_json(self):
return {
'id': self.id,
'username': self.username,
'email': self.email,
'active': self.active,
'created': self.created
}
class User(db.Model, UserMixin):
""" Users can have different roles """
__tablename__ = "users"
__table_args__ = {'extend_existing': True}
# id, username and password properties necessary for Flask-User
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(50), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
# Active and role will have to do with Flask-User
active = db.Column(db.Boolean(), nullable=False, server_default='0')
roles = db.relationship('Role', secondary='user_roles')
# Create admin user with 'Admin' role
@classmethod
def setAdmin(cls, username, password, user_manager):
if not cls.query.filter(cls.username == username).first():
print("setting admin")
user = cls(username=username,
password=user_manager.hash_password(password),
active=True)
db.session.add(user)
user.roles.append(Role.query.get(1))
db.session.commit()
else:
print("admin ok")
class Notification(db.Model):
"""Basic notification. We create one notification per object per user.
"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.id'), nullable=False)
notification_object_id = db.Column(db.Integer(),
db.ForeignKey('notification_object.id'), nullable=False)
notification_object = db.relationship('NotificationObject',
backref=db.backref('notification'))
is_read = db.Column(db.Boolean(), default=False)
date_read = db.Column(db.DateTime())
def get_subscription(self):
context_object_type_id = self.notification_object.context_object_type_id
context_object_id = self.notification_object.context_object_id
notification_subscription = NotificationSubscriptions.query\
.filter(NotificationSubscriptions.context_object_type_id == context_object_type_id)\
.filter(NotificationSubscriptions.context_object_id == context_object_id)\
.filter(NotificationSubscriptions.user_id == current_user.id)\
.first()
return notification_subscription
@property
def is_subscribed(self):
subscription = self.get_subscription()
if subscription:
return subscription.is_subscribed
else:
return False
def __str__(self):
return u"Notification {0}".format(self.id)
class User(db.Model, UserMixin):
"""Define the User data-model."""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
username = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
# Hierarchy
superior_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
subordinates = db.relationship('User',
backref=db.backref('superior',
remote_side=[id]))
# Define the relationship to Role via UserRole
roles = db.relationship('Role', secondary='user_roles')
# Define relationship to Allowance
allowances = db.relationship('Allowance')
class User(db.Model, UserMixin):
__tablenaem__ = 'user'
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(255), unique=True)
fullname = db.Column(db.String(255))
_password = db.Column('password', db.String(255))
active = db.Column(db.Boolean(), default=False)
create_at = db.Column(db.DateTime(), default=db.func.now())
posts = db.relationship('Post', backref='user', lazy='dynamic')
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('user', lazy='dynamic'))
def __str__(self):
return str(self.fullname)
@hybrid_property
def password(self):
return self._password
@password.setter
def password(self, new_pass):
if new_pass != self._password:
new_password_hash = utils.hash_password(new_pass)
self._password = new_password_hash
class User(Base):
__tablename__ = "account"
# Email = username. Uniqueness is enforced in auth/views.py
email = db.Column(db.String(144), nullable=False)
password = db.Column(db.String(144), nullable=False)
admin = db.Column(db.Boolean(), unique=False, default=False)
# One-To-Many relationship, each event has a creator
events = db.relationship("Event", backref='account', lazy=True)
performers = db.relationship("Performer", backref='account', lazy=True)
def __init__(self, email, password):
self.email = email
self.password = password
def get_id(self):
return self.id
def is_active(self):
return True
def is_anonymous(self):
return False
def is_authenticated(self):
return True
@staticmethod
def count_users_events(user=0):
stmt = text("SELECT COUNT(*) FROM Event e"
" WHERE e.account_id = :usr").params(usr=user)
res = db.engine.execute(stmt).fetchone()
return res[0]
class Submission(Base):
name = db.Column(db.String(144), nullable=False)
code = db.Column(db.String(1440), nullable=False)
description = db.Column(db.String(1440), nullable=False)
featured = db.Column(db.Boolean(), nullable=False)
account_id = db.Column(db.Integer,
db.ForeignKey('account.id'),
nullable=False)
comments = db.relationship("Comment",
backref='submission',
lazy=True,
cascade="delete")
def __init__(self, name):
self.name = name
self.code = "code isn't set here"
self.featured = False
@staticmethod
def count_submissions():
stmt = text("SELECT COUNT(Submission.id) FROM Submission")
res = db.engine.execute(stmt)
response = []
for row in res:
response.append(row[0])
return response[0]
class UserRequest(db.Model):
"""Define the UserRequest data-model"""
__tablename__ = 'user_requests'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
authorizer_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
request_date = db.Column(db.DateTime())
auth_date = db.Column(db.DateTime())
start_date = db.Column(db.DateTime())
end_date = db.Column(db.DateTime())
request_type_id = db.Column(
db.Integer(), db.ForeignKey('request_types.id', ondelete='CASCADE'))
prv_note_to_auth = db.Column(db.UnicodeText(255), server_default='')
prv_note_from_auth = db.Column(db.UnicodeText(255), server_default='')
pub_note = db.Column(db.UnicodeText(255), server_default='')
authorized = db.Column('is_authorized',
db.Boolean(),
nullable=False,
server_default='0')
# Define relationships to User
user = db.relationship('User', backref='requests', foreign_keys=[user_id])
authorizer = db.relationship('User',
backref='authorizations',
foreign_keys=[authorizer_id])
# Define relationship to RequestType
request_type = db.relationship('RequestType', backref='user_requests')
# Define relationship to Allowance
allowance = db.relationship(
'Allowance',
primaryjoin=
'and_(foreign(UserRequest.user_id) == remote(Allowance.user_id), foreign(UserRequest.request_type_id) == remote(Allowance.request_type_id))',
backref='user_requests')
class Worker(db.Model):
"""Workers are the render nodes of the farm
The creation of a Worker in the database happens automatically as soon
as it connects to the server and its MAC address does not match any
of the one already present in the database.
"""
id = db.Column(db.Integer, primary_key=True)
mac_address = db.Column(db.Integer())
hostname = db.Column(db.String(120))
status = db.Column(db.String(60))
warning = db.Column(db.Boolean())
config = db.Column(db.String(120))
system = db.Column(db.String(120))
ip_address = db.Column(db.String(32), unique=True)
connection = db.Column(db.String(64))
@property
def is_connected(self):
try:
urlopen("http://" + self.ip_address)
return True
except:
print "[Warning] Worker %s is not online" % self.hostname
return False
def __repr__(self):
return '<Worker %r>' % self.hostname
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), index=True, unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
active = db.Column(db.Boolean(), default=True)
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
secondary="roles_users",
backref=db.backref('users', lazy='dynamic'))
chats = db.relationship('Chat',
secondary="chat_users",
backref="chats",
lazy='dynamic')
def __repr__(self):
return '<User %r>' % (self.email)
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
class User(Base):
__tablename__ = "account"
full_name = db.Column(db.String(144), nullable=False)
username = db.Column(db.String(144), nullable=False)
password = db.Column(db.String(144), nullable=False)
role = db.Column(db.String(144), nullable=False)
admin = db.Column(db.Boolean())
posts = db.relationship("Post", backref='account', lazy=True)
def __init__(self, full_name, username, password, role, admin):
self.full_name = full_name
self.username = username
self.password = password
self.role = role
self.admin = admin
def get_id(self):
return self.id
def is_active(self):
return True
def is_anonymous(self):
return False
def is_authenticated(self):
return True
def roles(self):
return [self.role]
class User(db.Model, RoleFreeUserMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255))
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime())
user_type = db.Column(db.Enum(TypeOfUser, name="type_of_user_types"), nullable=False)
capabilities = db.Column(MutableList.as_mutable(ARRAY(db.String)), default=[])
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(16))
current_login_ip = db.Column(db.String(16))
login_count = db.Column(db.Integer)
failed_login_count = db.Column(db.Integer, default=0)
# relationships
measures = db.relationship(
"Measure",
lazy="subquery",
secondary="user_measure",
primaryjoin="User.id == user_measure.columns.user_id",
secondaryjoin="Measure.id == user_measure.columns.measure_id",
back_populates="shared_with",
)
__table_args__ = (UniqueConstraint(email, name="uq_users_email"),)
def user_name(self):
return self.email.split("@")[0]
def is_departmental_user(self):
return self.user_type == TypeOfUser.DEPT_USER
def is_rdu_user(self):
return self.user_type == TypeOfUser.RDU_USER
def is_admin_user(self):
return self.user_type == TypeOfUser.ADMIN_USER
def can(self, capability):
return capability in self.capabilities
def can_access_measure(self, measure):
if self.user_type != TypeOfUser.DEPT_USER:
return True
else:
return self in measure.shared_with
# DEPRECATED: use `can_access_measure` method instead.
def can_access(self, measure_slug):
if self.user_type != TypeOfUser.DEPT_USER:
return True
else:
if any(measure.slug == measure_slug for measure in self.measures):
return True
else:
return False
class lists(db.Model):
__table_args__ = { 'schema': 'livestreams' }
__tablename__ = 'list'
livestream_code = db.Column(db.String(), primary_key=True)
title = db.Column(db.String())
date = db.Column(db.String())
completed = db.Column(db.Boolean())
ongoing = db.Column(db.Boolean())
def serialize(self):
return {
'livestreamCode': self.livestream_code,
'title': self.title,
'date': self.date,
'ongoing': self.ongoing,
}
class Comment(db.Model):
__tablename__='comments'
commentID = db.Column(db.Integer(), primary_key=True)
body = db.Column(db.Text())
comment_date = db.Column(db.DateTime(), default=datetime.utcnow())
disabled = db.Column(db.Boolean(), default=False)
userID = db.Column(db.Integer(), db.ForeignKey('users.userID'))
postID = db.Column(db.Integer(), db.ForeignKey('posts.postID'))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255), unique=True)
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())
wells = db.relationship('Well', backref=backref('user'))
class User(Base, UserMixin):
__tablename__ = "account"
name = db.Column(db.String(144), nullable=False, unique=True)
username = db.Column(db.String(144), nullable=False, unique=True)
password = db.Column(db.String(144), nullable=False)
active = db.Column(db.Boolean())
posts = db.relationship("Post", backref="account", lazy=True, cascade="all, delete-orphan")
threads = db.relationship("Thread", backref="account", lazy=True, cascade="all, delete-orphan")
roles = db.relationship("Role", secondary=user_role, backref="User")
def __init__(self, name, username, password, active=False, roles=[]):
self.name = name
self.username = username
self.password = password
self.active = active
self.roles = roles
def get_id(self):
return self.id
def is_active(self):
if self.active is None:
return False
return self.active
def is_anonymous(self):
return False
def is_authenticated(self):
return True
@staticmethod
def find_usernames():
statement = text(
"SELECT account.name, account.username FROM account")
res = db.engine.execute(statement)
response = []
for row in res:
response.append({row[0]})
response.append({row[1]})
return response
@staticmethod
def find_users_with_no_posts():
statement = text(
"SELECT account.id, account.name FROM account LEFT JOIN Post ON Post.account_id = account.id GROUP BY account.id HAVING COUNT(Post.id) = 0")
res = db.engine.execute(statement)
response = []
for row in res:
response.append({"id": row[0], "name": row[1]})
return response
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
username = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
deleted = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
signup_date = db.Column(db.DateTime(), default=datetime.datetime.now)
karma = db.relationship('UserKarma',
backref=db.backref('user'),
uselist=False)
roles = db.relationship('Role',
secondary='roles_users',
backref=db.backref('users', lazy='dynamic'))
def gravatar(self, size=64):
parameters = {'s': str(size), 'd': 'mm'}
return "https://www.gravatar.com/avatar/" + \
hashlib.md5(self.email.lower()).hexdigest() + \
"?" + urllib.urlencode(parameters)
def update_karma(self):
self.karma.value = self.karma.positive - self.karma.negative
db.session.commit()
@property
def string_id(self):
return str(self.id)
@property
def role_ids(self):
return [r.id for r in self.roles]
# Required for administrative interface
def __str__(self):
return self.email
class User(Base):
__tablename__ = "account"
name = db.Column(db.String(144), nullable=False)
username = db.Column(db.String(144), nullable=False)
password = db.Column(db.String(144), nullable=False)
admin = db.Column(db.Boolean(), nullable=False)
submissions = db.relationship("Submission", backref='account', lazy=True)
comments = db.relationship("Comment", backref='account', lazy=True)
def __init__(self, name, username, password):
self.name = name
self.username = username
self.password = password
self.admin = False
def get_id(self):
return self.id
def is_active(self):
return True
def is_anonymous(self):
return False
def is_authenticated(self):
return True
@staticmethod
def count_users():
stmt = text("SELECT COUNT(Account.id) FROM Account")
res = db.engine.execute(stmt)
response = []
for row in res:
response.append(row[0])
return response[0]
@staticmethod
def list_users():
stmt = text(
"select account.username, count (submission.id), account.id from account left join submission on submission.account_id = account.id group by account.id having count(submission.id) != 0 order by 0 - count(submission.id)"
)
res = db.engine.execute(stmt)
response = []
for row in res:
response.append({
"username": row[0],
"levels": row[1],
"id": row[2]
})
return response
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
card_number = db.Column(db.String(19), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
total = db.Column(db.Integer)
active = db.Column(db.Boolean(), nullable=False)
roles = db.Column(db.ARRAY(db.Integer), default=[])
invalid_pass_inputs = db.Column(db.Integer, default=0)
def __repr__(self):
return f'<User {self.card_number}>'
class Playlist(db.Model):
__tablename__ = 'playlist'
id = db.Column(db.Integer, primary_key=True)
playlist_id = db.Column(db.String())
name = db.Column(db.String())
owner = db.Column(db.String())
checked = db.Column(db.Boolean())
def __init__(self, playlist_id, name, owner):
self.playlist_id = playlist_id
self.name = name
self.owner = owner
self.checked = False
class Bid(db.Model):
__tablename__ = 'bids'
id = db.Column(db.Integer, primary_key=True)
item_id = db.Column(db.Integer, db.ForeignKey('items.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
amount = db.Column(db.Float())
winner = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.BigInteger())
bid_detail = db.relationship("BidDetail", uselist=False, backref="bids")
def __repr__(self):
return '<id {}>'.format(self.id)
class CategorisationByDimension(db.Model):
__tablename__ = "categorisations_by_dimension"
subtopic_guid = db.Column("subtopic_guid", db.String())
page_guid = db.Column("page_guid", db.String())
page_title = db.Column("page_title", db.String())
page_version = db.Column("page_version", db.String())
page_uri = db.Column("page_uri", db.String())
page_position = db.Column("page_position", db.Integer())
dimension_guid = db.Column("dimension_guid", db.String())
dimension_title = db.Column("dimension_title", db.String())
dimension_position = db.Column("dimension_position", db.Integer())
categorisation_id = db.Column("categorisation_id", db.Integer())
categorisation = db.Column("categorisation", db.String())
categorisation_position = db.Column("categorisation_position", db.Integer())
includes_parents = db.Column("includes_parents", db.Boolean())
includes_all = db.Column("includes_all", db.Boolean())
includes_unknown = db.Column("includes_unknown", db.Boolean())
__table_args__ = (
PrimaryKeyConstraint("dimension_guid", "categorisation_id", name="categorisation_by_dimension_value_pk"),
{},
)
class NotificationSubscriptions(db.Model):
"""For every object supporting subscriptions, we create an relation with
each user interactig with it.
"""
id = db.Column(db.Integer, primary_key=True)
# 1: post, 2: comment
context_object_type_id = db.Column(db.Integer(), nullable=False)
context_object_id = db.Column(db.Integer(), nullable=False)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.id'), nullable=False)
is_subscribed = db.Column(db.Boolean(), default=True)
def __str__(self):
return u"NotificationSubscription {0}".format(self.id)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
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())
last_login_ip = db.Column(db.String(32))
current_login_ip = db.Column(db.String(32))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
class SpotifyUserSongInPlaylist(db.Model):
__tablename__ = 'spotifyusersonginplaylist'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String())
date_added = db.Column(db.DateTime())
track_id = db.Column(db.String())
popularity = db.Column(db.Integer())
explicit = db.Column(db.Boolean())
def __init__(self, user_id, date_added, track_id, popularity, explicit):
self.user_id = user_id
self.date_added = date_added
self.track_id = track_id
self.popularity = popularity
self.explicit = explicit
