class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Text, unique=True)
email = db.Column(db.Text, unique=True)
password = db.Column(db.Text)
preferences = db.relationship("Preference",
secondary=UserPreference,
backref=db.backref('user'))
podcasts = db.relationship("Podcast",
secondary=UserPodcast,
backref='user',
lazy='dynamic')
playlist = db.Column(db.Text)
liked_podcasts = db.relationship('Podcast',
secondary=LikedPodcasts,
backref=db.backref('users',
lazy='dynamic'),
lazy='dynamic')
## Add a column to hold all podcasts for a user? And/or all liked podcasts? Need a through table and form/button for liking pods
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password = bcrypt.generate_password_hash(password).decode('UTF-8')
def setpassword(self):
self.password = bcrypt.generate_password_hash(password).decode('UTF-8')
def __repr__(self):
return "#{}- Username: {}".format(self.id, self.username)
class Edge(db.Model):
__tablename__ = "edge"
__table_args__ = {'extend_existing': True}
lower_id = db.Column(db.Integer,
db.ForeignKey("node.node_id", ondelete="CASCADE"),
primary_key=True)
higher_id = db.Column(db.Integer,
db.ForeignKey("node.node_id", ondelete="CASCADE"),
primary_key=True)
lower_node = db.relationship(
Node,
primaryjoin=lower_id == Node.node_id,
backref=db.backref(
"lower_edges",
cascade="save-update, merge, delete, delete-orphan"))
higher_node = db.relationship(
Node,
primaryjoin=higher_id == Node.node_id,
backref=db.backref(
"higher_edges",
cascade="save-update, merge, delete, delete-orphan"))
def __init__(self, n1, n2):
self.lower_node = n1
self.higher_node = n2
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.Text, unique=True)
username = db.Column(db.Text, unique=True)
first_name = db.Column(db.Text)
last_name = db.Column(db.Text)
image_url = db.Column(db.Text)
header_image_url = db.Column(db.Text)
bio = db.Column(db.Text)
location = db.Column(db.Text)
password = db.Column(db.Text)
messages = db.relationship('Message', backref='user', lazy='dynamic')
liked_messages = db.relationship("Message",
secondary=UserLikes,
backref=db.backref('users_liked',
lazy='dynamic'),
lazy='dynamic')
followers = db.relationship(
"User",
secondary=FollowersFollowee,
primaryjoin=(FollowersFollowee.c.follower_id == id),
secondaryjoin=(FollowersFollowee.c.followee_id == id),
backref=db.backref('following', lazy='dynamic'),
lazy='dynamic')
def __init__(self, email, username, password):
self.email = email
self.username = username
self.password = bcrypt.generate_password_hash(password).decode('UTF-8')
def __repr__(self):
return f"#{self.id}: email: {self.email} - username: {self.username}"
def is_followed_by(self, user):
return bool(self.followers.filter_by(id=user.id).first())
def is_following(self, user):
return bool(self.following.filter_by(id=user.id).first())
def does_like(self, message):
return bool(self.liked_messages.filter_by(id=message.id).first())
def show_follow(self, user):
return bool(self.id != user.id)
@classmethod
def authenticate(cls, username, password):
found_user = cls.query.filter_by(username=username).first()
if found_user:
is_authenticated = bcrypt.check_password_hash(
found_user.password, password)
if is_authenticated:
return found_user
return False
class MatchHero(db.Model):
__tablename__ = 'match_hero'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
match_id = db.Column(db.Integer, db.ForeignKey('matches.id'), primary_key=True)
hero_id = db.Column(db.Integer, db.ForeignKey('heroes.id'), primary_key=True)
team = db.Column(db.String, nullable=False)
win = db.Column(db.Boolean, nullable=False)
match = db.relationship("Match", backref=db.backref('heroes'))
hero = db.relationship("Hero", backref=db.backref('matches'))
class Grupos(db.Model):
grupo_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name_group = db.Column(db.String, nullable=False)
elementos = db.relationship('Aparatos',
secondary=element,
backref=db.backref('elementos',
lazy='dynamic'))
users = db.relationship('Usuario',
secondary=subs,
backref=db.backref('users', lazy='dynamic'))
class Association(db.Model):
__tablename__ = 'association'
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True)
recipe_id = db.Column(db.Integer, db.ForeignKey('recipes.id'), primary_key=True)
user = db.relationship("User", backref=db.backref("association", cascade="all, delete-orphan" ))
recipe = db.relationship("Recipe", backref=db.backref("association", cascade="all, delete-orphan" ))
def __init__(self, user=None, recipe=None):
self.user = user
self.recipe = recipe
class Recipe_ingre(db.Model):
__tablename__ = 'recipe_ingre'
recipe_id = db.Column(db.Integer, db.ForeignKey('recipes.id'), primary_key=True)
ingre_id = db.Column(db.Integer, db.ForeignKey('ingres.id'), primary_key=True)
recipe = db.relationship("Recipe", backref=db.backref("recipe_ingre", cascade="all, delete-orphan" ))
ingre = db.relationship("Ingre", backref=db.backref("recipe_ingre", cascade="all, delete-orphan" ))
def __init__(self, recipe=None, ingre=None):
self.recipe = recipe
self.ingre = ingre
class Event(db.Model):
__tablename__ = "events"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
event_descriptor_id = db.Column(db.Integer,
db.ForeignKey('event_descriptors.id'),
nullable=False)
event_descriptor = db.relationship('EventDescriptor',
backref=db.backref('events',
lazy='joined'))
entity_type = db.Column(db.String(128))
entity_id = db.Column(db.Integer)
entity_description = db.Column(db.String(128))
entity_2_type = db.Column(db.String(128))
entity_2_id = db.Column(db.Integer)
entity_2_description = db.Column(db.String(128))
entity_3_type = db.Column(db.String(128))
entity_3_id = db.Column(db.Integer)
entity_3_description = db.Column(db.String(128))
expiration_date = db.Column(db.DateTime)
group_id = db.Column(db.Integer, db.ForeignKey('groups.id'))
group = db.relationship('Group',
backref=db.backref('events', lazy='joined'))
is_processed = db.Column(db.Boolean, default=False, nullable=False)
creator_id = db.Column(db.Integer, db.ForeignKey('users.id'))
creator = db.relationship('User',
backref=db.backref('events', lazy='joined'))
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow,
onupdate=datetime.utcnow)
def __init__(self, event_descriptor_id: int):
self.event_descriptor_id = event_descriptor_id
def push_notification_data(self):
event_descriptor = self.event_descriptor
message_template = event_descriptor.description
if self.entity_description:
message_template = message_template.replace(
"{1}", self.entity_description)
if self.entity_2_description:
message_template = message_template.replace(
"{2}", self.entity_2_description)
if self.entity_3_description:
message_template = message_template.replace(
"{3}", self.entity_3_description)
devices = Device.query_active_devices_for_group(
group=self.group, discard_user_ids=[self.creator_id]).all()
pn_tokens = [device.pn_token for device in devices]
return "Hi", message_template, pn_tokens
class Interviewer_assigned(db.Model):
__tablename__ = "interviewer_assigned"
id = db.Column(db.Integer, primary_key=True)
interviewer_id = db.Column(db.Integer, db.ForeignKey('interviewer.id'))
interview_id = db.Column(db.Integer, db.ForeignKey('interview.id'))
interview = db.relationship("Interview",
backref=db.backref("interviewer_assigned",
cascade="all"))
interviewer = db.relationship("Interviewer",
backref=db.backref("interviewer_assigned",
cascade="all"))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.Text, unique=True)
username = db.Column(db.Text, unique=True)
image_url = db.Column(db.Text)
password = db.Column(db.Text)
messages = db.relationship('Message', backref='user', lazy='dynamic')
followers = db.relationship(
"User",
secondary=FollowersFollowee,
primaryjoin=(FollowersFollowee.c.follower_id == id),
secondaryjoin=(FollowersFollowee.c.followee_id == id),
backref=db.backref('following', lazy='dynamic'),
lazy='dynamic')
def __init__(
self,
email,
username,
password,
image_url='https://pbs.twimg.com/profile_images/524943875543420928/-0QwXz_i.jpeg'
):
self.email = email
self.username = username
self.image_url = image_url
self.password = bcrypt.generate_password_hash(password).decode('UTF-8')
def is_followed_by(self, user):
return bool(self.followers.filter_by(id=user.id).first())
def is_following(self, user):
return bool(self.following.filter_by(id=user.id).first())
class Project(db.Model):
__tablename__ = "project"
project_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
release_date = db.Column(db.Date, nullable=False)
website_url = db.Column(db.Text, nullable=False)
logo_url = db.Column(db.Text, nullable=False)
description = db.Column(db.Text, nullable=False)
platforms = db.relationship("Platform",
secondary=project_platform,
lazy="subquery",
backref=db.backref("projects", lazy=True))
def to_dict(self):
project_dict = {
"project_id": self.project_id,
"name": self.name,
"release_date": self.release_date.strftime("%Y-%m-%d"),
"website_url": self.website_url,
"logo_url": self.logo_url,
"description": self.description,
"platforms": [platform.to_dict() for platform in self.platforms]
}
return project_dict
def to_partial_dict(self):
project_dict = {
"project_id": self.project_id,
"name": self.name,
"logo_url": self.logo_url,
}
return project_dict
class UnFollow_Schedule(Base):
__tablename__ = "unfollow_schedule"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
accountid = db.Column(db.Integer, ForeignKey(Account.id), nullable=False)
start_time = db.Column(db.DateTime, nullable=False)
end_time = db.Column(db.DateTime, nullable=False)
max_unfollows = db.Column(db.Integer, nullable=False, default=0)
option = db.Column(db.Boolean, nullable=False, default=False)
account = relationship("Account",
backref=db.backref('children_unfollow_schedule',
cascade='all,delete'))
def __init__(self, accountid, start_time, end_time, max_unfollows, option):
self.accountid = accountid
self.start_time = start_time
self.end_time = end_time
self.max_unfollows = max_unfollows
self.option = option
def get_id(self):
return self.id
def __repr__(self):
return '<UnFollow_Schedule {0}>'.format(self.id)
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, nullable=False)
active = db.Column(db.Boolean(), nullable=False, default=True)
apikey = db.Column(db.String(36),
index=True,
unique=True,
nullable=False,
default=generate_apikey)
email = db.Column(db.String(255), nullable=False, unique=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(130), nullable=False)
roles = db.relationship('Role',
secondary=roles_users_association,
backref=db.backref('users', lazy='dynamic'))
username = db.Column(db.String(255), nullable=False, unique=True)
def __str__(self):
return str(self.username)
def to_dict(self):
return {
'id': self.id,
'active': self.active,
'email': self.email,
'first_name': self.first_name,
'last_name': self.last_name,
'roles': sorted([r.name for r in self.roles]),
'username': self.username
}
class Product(db.Model):
__tablename__ = 'product'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
receipt_id = db.Column(db.Integer,
db.ForeignKey('receipt.id'),
nullable=False)
receipt = db.relationship('Receipt',
backref=db.backref('products',
lazy=True,
cascade='all, delete-orphan'))
quantity = db.Column(db.Integer, nullable=False)
unit_price = db.Column(db.Float, nullable=False)
def __init__(self, receipt_id, quantity, unit_price):
self.receipt_id = receipt_id
self.quantity = quantity
self.unit_price = unit_price
def to_json(self):
return {
'id': self.id,
'receipt_id': self.receipt_id,
'quantity': self.quantity,
'unit_price': self.unit_price
}
class Investor(db.Model):
__tablename__ = "investors"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
url = db.Column(db.Text)
country = db.Column(db.Text)
markets = db.relationship('Market',
secondary=InvestorsMarkets,
backref=db.backref('investors', lazy='dynamic'),
lazy='dynamic')
def __init__(self, name, url, country):
self.name = name
self.url = url
self.country = country
def get_market_names(self):
return ", ".join([market.name for market in self.markets])
@classmethod
def get_investors_in_market(cls, market_name):
return db.session.query(Investor, InvestorsMarkets, Market).filter(
Investor.id == InvestorsMarkets.c.investor_id).filter(
InvestorsMarkets.c.market_id == Market.id).filter(
Market.name == market_name)
class Event(db.Model):
__tablename__ = 'events'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), nullable=False)
location = db.Column(db.String(256))
description = db.Column(db.String(1024))
duration = db.Column(db.Integer, nullable=False)
url = db.Column(db.String(32), nullable=False, unique=True)
color = db.Column(db.String(6), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
availability_id = db.Column(db.Integer,
db.ForeignKey('availability.id'),
nullable=False)
availability = db.relationship('Availability',
innerjoin=True,
lazy='joined',
cascade="all, delete-orphan",
single_parent=True,
backref=db.backref('event', uselist=False))
def __iter__(self):
values = vars(self)
for attr in self.__table__.columns.keys():
if attr in values:
yield attr, values[attr]
def logme(self):
return dict(self)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Text, unique=True)
password = db.Column(db.Text)
first_name = db.Column(db.Text)
last_name = db.Column(db.Text)
messages = db.relationship(
"Message", secondary=UserMessages, backref=db.backref("users")
)
def __init__(self, first_name, last_name, username, password):
self.first_name = first_name
self.last_name = last_name
self.username = username
self.password = bcrypt.generate_password_hash(password).decode("UTF-8")
@classmethod
def authenticate(cls, username, password):
found_user = cls.query.filter_by(username=username).first()
if found_user:
is_authenticated = bcrypt.check_password_hash(found_user.password, password)
if is_authenticated:
return found_user
return False
class Position(db.Model):
__tablename__ = "positions"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50))
description = db.Column(db.String(140))
# shifts connected to Position
assigned_shifts = db.relationship('Shift',
backref='Position', lazy='dynamic')
# Organization associated with shift
organization_id = db.Column(db.Integer, db.ForeignKey('organizations.id'))
# Users many to many relationship with position
assigned_users = db.relationship(
'User',
secondary=position_assignments,
backref=db.backref('Position', lazy='dynamic'))
color = db.Column(db.String(7))
def __init__(self, title, description, organization_id):
self.title = title
self.organization_id = organization_id
self.description = description
self.color = random_color()
def __repr__(self):
return '<title: {}>'.format(self.title)
class Interview(db.Model):
__tablename__ = "interview"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(32))
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
candidate_id = db.Column(db.Integer,
db.ForeignKey('candidates.id'),
unique=True)
candidates = db.relationship("Candidates",
backref=db.backref("interview",
uselist=False))
interviewer = db.relationship("Interviewer",
secondary="interviewer_assigned",
cascade="all")
# Class constuctor
def __init__(self, title, start_time, end_time):
self.title = title
self.start_time = start_time
self.end_time = end_time
# Returning class attribute in json format
def to_json(self):
return {
"id": self.id,
"candidate_id": self.candidate_id,
"title": self.title,
"start_time": self.start_time,
"end_time": self.end_time
}
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.Text, unique=True)
username = db.Column(db.Text, unique=True)
name = db.Column(db.Text)
image_url = db.Column(db.Text)
header_image_url = db.Column(db.Text)
bio = db.Column(db.Text)
# HEY THE BIO IS RIGHT HERE
location = db.Column(db.Text)
password = db.Column(db.Text)
messages = db.relationship('Message', backref='user', lazy='dynamic')
followers = db.relationship(
"User",
secondary=FollowersFollowee,
primaryjoin=(FollowersFollowee.c.follower_id == id),
secondaryjoin=(FollowersFollowee.c.followee_id == id),
backref=db.backref('following', lazy='dynamic'),
lazy='dynamic')
def __init__(self,
email,
username,
password,
image_url='/static/images/default-pic.png'):
self.email = email
self.username = username
self.image_url = image_url
self.password = bcrypt.generate_password_hash(password).decode('UTF-8')
likes = db.relationship("Message",
secondary=UserLikedMessages,
backref=db.backref('liked_by', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return f"#{self.id}: email: {self.email} - username: {self.username}"
def is_followed_by(self, user):
return bool(self.followers.filter_by(id=user.id).first())
def is_following(self, user):
return bool(self.following.filter_by(id=user.id).first())
class Patent(db.Model):
__tablename__ = "patent"
id = db.Column(db.Integer, primary_key=True)
human_id = db.Column(db.Integer, db.ForeignKey('human.id'), nullable=False)
title = db.Column(db.String(200), nullable=False)
description = db.Column(db.String(250), nullable=False)
patent_number = db.Column(db.String(20), nullable=False)
inventors = db.Column(db.String(250), nullable=False)
issue_date = db.Column(db.DateTime, nullable=True)
patent_office_id = db.Column(db.Integer, db.ForeignKey('patent_office.id'))
patent_office = db.relationship('PatentOffice', backref=db.backref('patent', lazy='dynamic'))
patent_status_id = db.Column(db.Integer, db.ForeignKey('patent_status.id'))
patent_status = db.relationship('PatentStatus', backref=db.backref('patent', lazy='dynamic'))
patent_url = db.Column(db.String(100), nullable=True)
def __repr__(self):
return self.status
class Device(db.Model):
__tablename__ = "devices"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
device_id = db.Column(db.String(128), unique=True, nullable=False)
device_type = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
pn_token = db.Column(db.String(256), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', backref=db.backref('devices', lazy='joined'))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow, onupdate=datetime.utcnow)
def __init__(self, device_id: str, device_type: str, pn_token: str=None, active: bool=True, user=None, created_at: datetime=datetime.utcnow()):
self.device_id = device_id
self.device_type = device_type # "apple" "android"
self.pn_token = pn_token
self.active = active
self.user = user
self.created_at = created_at
self.updated_at = created_at
# noinspection PyPep8
@staticmethod
def query_active_devices_for_user(user: User):
return Device.query.filter(Device.user_id == user.id, Device.active == True, Device.pn_token.isnot(None))
# noinspection PyPep8
@staticmethod
def query_active_devices_for_group(group: Group, discard_user_ids:List[int]=None):
discard_user_ids = discard_user_ids or []
user_ids = [user.user_id for user in group.associated_users if user.user_id not in discard_user_ids]
return Device.query.filter(Device.user_id.in_(tuple(user_ids)), Device.active == True,
Device.pn_token.isnot(None))
@staticmethod
def create_or_update(device_id, device_type: str, user:User=None, active: bool = True, pn_token: str=None):
device = Device.first_by(device_id=device_id)
if not device:
device = Device(device_id=device_id, device_type=device_type, user=user, active=active, pn_token=pn_token)
db.session.add(device)
else:
device.device_type = device_type
device.active = active
if user:
device.user = user
if pn_token:
device.pn_token = pn_token
return device
@staticmethod
def first_by(**kwargs):
"""Get first db device that match to device_id"""
return Device.query.filter_by(**kwargs).first()
@staticmethod
def first(*criterion):
"""Get first db entity that match to criterium"""
return Device.query.filter(*criterion)
class Post(db.Model):
__tablename__ = 'blog_post'
id = db.Column('post_id', db.Integer, primary_key=True)
uuid = db.Column('uuid', db.String(SIZE_UUID), unique=True)
slug = db.Column('slug', db.String(SIZE_TITLE), unique=True, index=True)
description = db.Column('description', db.String(SIZE_META), default='')
keywords = db.Column('keywords', db.String(SIZE_META), default='')
status = db.Column('status', db.SmallInteger, default=POST_STATUS_DRAFT)
added = db.Column('added', db.DateTime)
published = db.Column('published', db.DateTime)
sticked = db.Column('sticked', db.Boolean, default=False)
ping = db.Column('ping', db.Boolean, default=False)
comments_enabled = db.Column('comments_enabled', db.Boolean, default=True)
comments_moderated = db.Column('comments_moderated',
db.Boolean,
default=False)
template = db.Column('template',
db.SmallInteger,
default=POST_TEMPLATE_TEXT)
title = db.Column('title', db.String(SIZE_TITLE), index=True, default='')
teaser = db.Column('teaser', db.Text, default='')
content = db.Column('content', db.Text, default='')
prev = db.Column('prev', db.Text, default='')
tags = db.relationship('Tag',
secondary=tags,
backref=db.backref('posts', lazy='dynamic'))
categories = db.relationship('Category',
secondary=categories,
backref=db.backref('posts', lazy='dynamic'))
user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'))
def __init__(self):
self.uuid = str(uuid4())
self.added = datetime.utcnow()
def __repr__(self):
return '<Post: %s>' % self.title
@staticmethod
def exist(slug):
if Post.query.filter_by(slug=slug).first() is None:
return False
else:
return True
class Quote(db.Model):
__tablename__ = "quote"
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String, nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey('author.id'))
author = db.relationship(
'Author',
backref=db.backref('quotes', lazy='dynamic'),
)
posted_at = db.Column(db.DateTime)
class User(db.Model):
__tablename__ = "user"
user_id = db.Column(db.String(36), primary_key=True)
username = db.Column(db.String(255), unique=True, nullable=False)
hashed_password = db.Column(db.String(64), nullable=False)
birthdate = db.Column(db.DateTime)
profiles = db.relationship(
"Profile", secondary=user_profile, lazy="subquery",
backref=db.backref("user_profiles", lazy=True)
)
def to_json(self):
user_dict = {
"accountId": self.user_id,
"profiles": [],
"hashedCredentials": self.username + ":" + self.hashed_password
}
for profile in self.profiles:
user_dict["profiles"].append(profile.name)
return user_dict
def encode_auth_token(self):
"""Generates the auth token"""
now = datetime.datetime.utcnow()
delta = datetime.timedelta(
days=current_app.config.get("TOKEN_EXPIRATION_DAYS"),
seconds=current_app.config.get("TOKEN_EXPIRATION_SECONDS")
)
try:
payload = {
"exp": now + delta,
"iat": now,
"sub": self.user_id
}
return jwt.encode(
payload,
current_app.config.get("SECRET_KEY"),
algorithm="HS256"
)
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""Decodes the auth token"""
try:
payload = jwt.decode(
auth_token,
current_app.config.get("SECRET_KEY")
)
return (True, payload["sub"])
except jwt.ExpiredSignatureError:
return (False, "Signature expired. Please log in again.")
except jwt.InvalidTokenError:
return (False, "Invalid token. Please log in again.")
class Tag(db.Model):
__tablename__ = "tags"
id = db.Column(db.Integer, primary_key=True)
tag = db.Column(db.Text)
messages = db.relationship("Message",
secondary=MessageTags,
backref=db.backref("tags"))
def __init__(self, tag):
self.tag = tag
class Graph(db.Model):
id = db.Column(db.String(7), primary_key=True, unique=True)
tags = db.relationship('Tag',
secondary=tags,
backref=db.backref('graphs', lazy='dynamic'))
def __init__(self, idx):
self.id = idx
def __repr__(self):
return '<Graph {}>'.format(self.id)
class Meetup(OutputMixin, db.Model):
__tablename__ = "meetup"
id = Column(
UUID(as_uuid=True),
primary_key=True,
server_default=sqlalchemy.text("uuid_generate_v4()"),
)
name = Column(db.String(128), nullable=False)
logo = Column(db.String(1000), nullable=False)
url = Column(db.String(2048), nullable=False)
description = Column(db.String(50000), nullable=False)
topics = db.relationship(
"Topic",
secondary=meetup_topic_table,
backref=db.backref("meetup", lazy="dynamic"),
)
events = db.relationship(
"Event",
secondary=meetup_event_table,
backref=db.backref("meetup", lazy="dynamic"),
)
channel = db.relationship(
"Channel",
secondary=meetup_channel_table,
backref=db.backref("meetup", lazy="dynamic"),
)
created = Column(db.DateTime, default=datetime.utcnow, nullable=False)
updated = Column(db.DateTime, default=datetime.utcnow, nullable=False)
deleted = Column(db.DateTime, nullable=True)
source = Column(db.String(50), nullable=False)
def __init__(self, name, logo, url, description, topics, events, channel, source):
self.name = name
self.logo = logo
self.url = url
self.description = description
self.topics = topics
self.events = events
self.channel = channel
self.source = source
class Exercise(db.Model):
__tablename__ = 'exercises'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, unique = True)
description = db.Column(db.Text)
bodyparts = db.relationship('BodyPart', secondary=BodyPartExercise, backref=db.backref('exercises'))
def __init__(self,name,description):
self.name = name
self.description = description
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
password = db.Column(db.String, nullable=False)
posts = db.relationship("BlogPost", backref="author")
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def __init__(self, name, email, password):
self.name = name
self.email = email
self.password = bcrypt.generate_password_hash(password).decode('utf-8')
def __repr__(self):
return '<name - {}>'.format(self.name)
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
def follow(self, user):
self.followed.append(user)
return self
def unfollow(self, user):
self.followed.remove(user)
return self
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
return BlogPost.query.join(
followers, (followers.c.followed_id == BlogPost.author_id)).filter(
followers.c.follower_id == self.id).order_by(
BlogPost.timestamp.desc())
