class Posts(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text, nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
start_date = db.Column(db.Date, nullable=False)
end_date = db.Column(db.Date, nullable=False)
country = db.Column(db.Text, nullable=False)
city = db.Column(db.Text, nullable=False)
latitude = db.Column(db.Float, nullable=False)
longitude = db.Column(db.Float, nullable=False)
content = db.Column(db.Text, nullable=False)
subscribers = db.relationship('Subscribed',
foreign_keys=[Subscribed.post_id],
backref=db.backref('post', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
notifiers = db.relationship('Notification',
foreign_keys=[Notification.post_id],
backref=db.backref('post', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
def __repr__(self):
return f"Posts('{self.date_posted}')"
class ProjectTeams(db.Model):
__tablename__ = "project_teams"
team_id = db.Column(db.Integer,
db.ForeignKey("teams.id"),
primary_key=True)
project_id = db.Column(db.Integer,
db.ForeignKey("projects.id"),
primary_key=True)
role = db.Column(db.Integer, nullable=False)
project = db.relationship("Project",
backref=db.backref("teams",
cascade="all, delete-orphan"))
team = db.relationship(Team,
backref=db.backref("projects",
cascade="all, delete-orphan"))
def create(self):
""" Creates and saves the current model to the DB """
db.session.add(self)
db.session.commit()
def save(self):
""" Save changes to db"""
db.session.commit()
def delete(self):
""" Deletes the current model from the DB """
db.session.delete(self)
db.session.commit()
class Service(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
description = db.Column(db.String(256))
price = db.Column(db.Float, nullable=True)
duration = db.Column(db.Interval, nullable=True)
performers = db.relationship('Performer', secondary=performer_service,
back_populates='services', lazy='dynamic')
business_id = db.Column(db.Integer, db.ForeignKey(
'business.id',
onupdate="CASCADE",
ondelete="CASCADE"
), nullable=False)
business = db.relationship("Business", back_populates='services')
appointments = db.relationship('Appointment', back_populates='service')
def to_obj(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'price': self.price,
'duration': str(self.duration),
'performers': list(map(lambda x: x.id, self.performers))
}
@staticmethod
def get(service_id):
return db.session.query(Service).get(service_id)
class BlogComment(db.Model):
id = db.Column(db.Integer, primary_key=True)
created = db.Column(db.DateTime,
server_default=db.func.now(),
onupdate=db.func.now())
modified = db.Column(db.DateTime, server_default=db.func.now())
# title = db.Column(db.String(128))
author = db.Column(db.String(128))
author_email = db.Column(db.String(128))
author_website = db.Column(db.String(128), nullable=True)
content = db.Column(db.Text)
by_author = db.Column(db.Boolean, default=False)
replied_to_id = db.Column(db.Integer,
db.ForeignKey('blog_comment.id'),
index=True)
replied_to = db.relationship(lambda: BlogComment,
remote_side=id,
backref=db.backref('sub_comments',
lazy='dynamic'))
post_id = db.Column(db.Integer, db.ForeignKey(BlogPost.id), index=True)
post = db.relationship(BlogPost,
backref=db.backref('comments', lazy='dynamic'))
class Member(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(30), nullable=False)
last_name = db.Column(db.String(30), nullable=False)
institution = db.Column(db.String(120), nullable=False)
is_executive_assistant = db.Column(db.Boolean)
is_archived = db.Column(db.Boolean)
executive_assistant_id = db.Column(db.Integer, db.ForeignKey('member.id'))
executive_assistant = db.relationship('Member',
backref='member_executive_assistant',
uselist=False,
remote_side=[id],
lazy=True)
emails = db.relationship('Email', backref='member', lazy=True)
phone_numbers = db.relationship('PhoneNumber', backref='member', lazy=True)
lists = db.relationship('List',
secondary=list_memberships,
backref=db.backref('members', lazy=True),
lazy=True)
cure_center_profile = db.relationship('CureCenterProfile',
backref='member',
uselist=False)
def __repr__(self):
return f"<Member(first='{self.first_name}', last='{self.last_name}')>"
class TeamMembers(db.Model):
__tablename__ = "team_members"
team_id = db.Column(db.Integer,
db.ForeignKey("teams.id", name="fk_teams"),
primary_key=True)
user_id = db.Column(db.BigInteger,
db.ForeignKey("users.id", name="fk_users"),
primary_key=True)
function = db.Column(db.Integer,
nullable=False) # either 'editor' or 'manager'
active = db.Column(db.Boolean, default=False)
member = db.relationship(User,
backref=db.backref("teams",
cascade="all, delete-orphan"))
team = db.relationship("Team",
backref=db.backref("members",
cascade="all, delete-orphan"))
def create(self):
""" Creates and saves the current model to the DB """
db.session.add(self)
db.session.commit()
def delete(self):
""" Deletes the current model from the DB """
db.session.delete(self)
db.session.commit()
class ClientSession(db.Model):
__tablename__ = "Client_sessions"
id = db.Column(db.Integer, primary_key=True)
client_weight = db.Column(db.Integer, nullable=True)
comment = db.Column(db.String, nullable=True)
name = db.Column(db.String, nullable=False)
slug = db.Column(db.String, nullable=False)
order = db.Column(db.Integer, nullable=False)
completed = db.Column(db.Boolean, nullable=False)
# many to one relationship with CLient_templates table
client_template_id = db.Column(db.Integer,
db.ForeignKey('Client_templates.id'),
nullable=False)
# one to many relationship with Client_exercises table
exercises = db.relationship('ClientExercise',
cascade="all, delete-orphan",
lazy=True,
order_by="ClientExercise.order")
# one to many relationship with Training_entries table
training_entries = db.relationship('TrainingEntry',
cascade="all, delete-orphan",
lazy=True,
order_by="TrainingEntry.order")
completed_date = db.Column(db.String, nullable=True)
class LabelValue(db.Model):
__tablename__ = "label_value"
id = db.Column("id", db.Integer(), primary_key=True)
label_id = db.Column(
"label_id", db.Integer(), db.ForeignKey("label.id"), nullable=False
)
value = db.Column("value", db.String(200), nullable=False)
created_at = db.Column(
"created_at", db.DateTime(), nullable=False, default=db.func.now()
)
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
__table_args__ = (
db.UniqueConstraint("label_id", "value", name="_label_id_value_uc"),
)
label = db.relationship("Label", backref="LabelValue")
segmentations = db.relationship(
"Segmentation", secondary=annotation_table, back_populates="values"
)
def set_label_value(self, value):
self.value = value
class Project(db.Model):
__tablename__ = "project"
id = db.Column("id", db.Integer(), primary_key=True)
name = db.Column("name", db.String(32), nullable=False, unique=True)
creator_user_id = db.Column(
"creator_user_id", db.Integer(), db.ForeignKey("user.id"), nullable=False
)
api_key = db.Column("api_key", db.String(32), nullable=False, unique=True)
created_at = db.Column(
"created_at", db.DateTime(), nullable=False, default=db.func.now()
)
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
users = db.relationship(
"User", secondary=user_project_table, back_populates="projects"
)
data = db.relationship("Data", backref="Project")
labels = db.relationship("Label", backref="Project")
creator_user = db.relationship("User")
class UserSong(db.Model):
__tablename__ = 'user_song'
user_id = db.Column('user_id',
db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE'),
primary_key=True)
song_id = db.Column('song_id',
db.Integer(),
db.ForeignKey('song.id', ondelete='RESTRICT'),
primary_key=True)
time_played = db.Column('time_played', db.DateTime(), primary_key=True)
user = db.relationship("User",
backref=db.backref('user_song', lazy='dynamic'))
song = db.relationship("Song")
def __init__(self, user, song, time_played):
self.user = user
self.song = song
self.time_played = time_played
def __repr__(self):
return '<User %s Song %s>' % (self.user.username, self.song.spot_id)
class Business(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=True, unique=True)
phone = db.Column(db.String(80), nullable=True)
address = db.Column(db.String(256), nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey(
'user.id',
onupdate="CASCADE",
ondelete="CASCADE"
), nullable=False)
services = db.relationship("Service", back_populates='business')
performers = db.relationship("Performer", back_populates='business')
def to_obj(self):
return {
'id': self.id,
'name': self.name,
'address': self.address,
'phone': self.phone,
'performers': list(map(lambda x: x.to_obj(), self.performers)),
'services': list(map(lambda x: x.to_obj(), self.services))
}
@staticmethod
def get(user_id):
return db.session.query(Business).filter(Business.user_id == user_id).first()
class ClientTemplate(db.Model):
__tablename__ = "Client_templates"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
slug = db.Column(db.String, nullable=False)
start_date = db.Column(db.String, nullable=False)
end_date = db.Column(db.String, nullable=True)
# many to one relationship with Users table
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User',
lazy=True,
uselist=False,
single_parent=True,
primaryjoin="User.id==ClientTemplate.user_id")
completed = db.Column(db.Boolean, nullable=False)
active = db.Column(db.Boolean, nullable=False)
# one to many relationship with Client_sessions
sessions = db.relationship('ClientSession',
cascade="all, delete-orphan",
lazy=True,
order_by="ClientSession.order")
# one to many relationship with Check_ins table
check_in = db.relationship(
'CheckIn',
lazy=True,
uselist=False,
single_parent=True,
primaryjoin="CheckIn.client_template_id==ClientTemplate.id")
class CoachExercise(db.Model):
__tablename__ = "Coach_exercises"
id = db.Column(db.Integer, primary_key=True)
# 1 to 1 relationship with Exercises
exercise_id = db.Column(db.Integer, db.ForeignKey('Exercises.id'), nullable=False)
category = db.relationship(Exercise, lazy=True, uselist=False, single_parent=True, primaryjoin="Exercise.id==CoachExercise.exercise_id")
name = db.relationship(Exercise, lazy=True, uselist=False, single_parent=True, primaryjoin="Exercise.id==CoachExercise.exercise_id")
# many to 1 relationship with Coach_sessions table
coach_session_id = db.Column(db.Integer, db.ForeignKey('Coach_sessions.id'), nullable=False)
order = db.Column(db.Integer, nullable=False)
class Album(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
name_id = db.Column(db.String(255), nullable=False)
total_tracks = db.Column(db.Integer)
year = db.Column(db.Integer)
disc_number = db.Column(db.Integer, server_default=u'1')
total_discs = db.Column(db.Integer, server_default=u'1')
songs = db.relationship('Song', lazy="joined")
artist_id = db.Column(db.Integer, db.ForeignKey('artist.id'))
artist = db.relationship('Artist',
lazy='joined',
cascade='all, delete-orphan',
single_parent=True)
count_songs = db.Column(db.Integer)
count_played = db.Column(db.Integer)
played_at = db.Column(db.DateTime, server_default=db.func.now())
count_rated = db.Column(db.Integer)
rated_at = db.Column(db.DateTime, server_default=db.func.now())
rating = db.Column(db.Float)
created_at = db.Column(db.DateTime, server_default=db.func.now())
updated_at = db.Column(db.DateTime,
server_default=db.func.now(),
onupdate=db.func.now())
def __init__(self, name, artist):
self.name = name
self.name_id = name.lower().strip()
self.artist = artist
def __json__(self):
return [
'id',
'name',
'total_tracks',
'disc_number',
'year',
'artist',
'count_songs',
'count_played',
'played_at',
'count_rated',
'rated_at',
'rating',
]
def __repr__(self):
return '<{} {}>'.format(self.__class__.__name__, self.id)
class User(db.Model, UserMixin):
id = db.Column(db.String(200), primary_key=True)
player_name = db.Column(db.String(20), unique=True, nullable=False)
accounts = db.relationship('Accounts', backref='user', lazy=True)
settings = db.relationship('Settings', backref='user', lazy=True)
clan_recruitment_posts = db.relationship('Clan_recruitment_post',
backref='user',
lazy=True)
player_recruitment_posts = db.relationship('Player_recruitment_post',
backref='user',
lazy=True)
def __repr__(self):
return f"User('{self.player_name}'"
class Group(db.Model):
id = db.Column(db.Integer, primary_key=True)
contact_id = db.Column(db.Integer,
db.ForeignKey('member.id'),
nullable=False)
contact = db.relationship('Member',
backref='group_contact',
uselist=False,
lazy=True)
name = db.Column(db.String(30), nullable=False)
members = db.relationship('Member', backref='group', lazy=True)
def __repr__(self):
return f"<Group(name='{self.name}')>"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
img = db.Column(db.String, nullable=False)
body = db.Column(db.String, nullable=False)
date_posted = db.Column(db.DateTime, default=datetime.utcnow)
likes = db.relationship('Like', backref='post', lazy=True)
comments = db.relationship('Comment', backref='post', lazy=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def get_users(self):
return [like.user_id for like in self.likes]
def __repr__(self):
return self.body[:10]
class Location(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), nullable=False)
patterns = db.relationship('Pattern', backref='location', lazy=True)
period = db.relationship('Period',
secondary=location_period,
lazy='subquery',
backref=db.backref('locations', lazy=True))
def toDict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class Performer(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
services = db.relationship('Service', secondary=performer_service,
back_populates='performers', lazy='dynamic')
phone = db.Column(db.String(80), nullable=True)
photo_id = db.Column(UUIDType(binary=False), db.ForeignKey(
'image.id',
onupdate="CASCADE",
ondelete="SET NULL"
), nullable=True)
description = db.Column(db.String(256))
business_id = db.Column(db.Integer, db.ForeignKey(
'business.id',
onupdate="CASCADE",
ondelete="CASCADE"
), nullable=False)
work_beg = db.Column(db.Interval, nullable=False, default=timedelta(hours=9))
work_end = db.Column(db.Interval, nullable=False, default=timedelta(hours=18))
lunch_beg = db.Column(db.Interval, nullable=False, default=timedelta(hours=12))
lunch_end = db.Column(db.Interval, nullable=False, default=timedelta(hours=13))
non_working_days = db.Column(
db.ARRAY(db.Integer), nullable=False, default=[])
business = db.relationship("Business", back_populates='performers')
appointments = db.relationship('Appointment', back_populates='performer')
def to_obj(self):
return {
'id': self.id,
'name': self.name,
'phone': self.phone,
'photo': self.photo_id,
'description': self.description,
'services': list(map(lambda x: x.id, self.services))
}
def get_working_hours(self):
if not self.work_beg:
return timedelta(hours=9), timedelta(hours=18)
return self.work_beg, self.work_end
def get_lunch_hours(self):
if not self.lunch_beg:
return timedelta(hours=12), timedelta(hours=13)
return self.lunch_beg, self.lunch_end
@staticmethod
def get(performer_id):
return db.session.query(Performer).get(performer_id)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
cart_items = db.relationship('Product',
secondary=cart,
lazy='subquery',
backref=db.backref('in_cart_of', lazy=True))
uploaded_products = db.relationship('Product',
backref='uploaded_by',
lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}')"
class CollectionMembership(db.Model):
id = db.Column(db.Integer, primary_key=True)
book_id = db.Column(db.Integer, db.ForeignKey("book.id"))
collection_id = db.Column(
db.Integer, db.ForeignKey("collection.id", ondelete="CASCADE"))
date_added = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow())
collection = db.relationship("Collection",
back_populates="book_memberships")
book = db.relationship("Book", back_populates="collection_memberships")
def __repr__(self):
return f"<Membership(id='{self.id}', book_title='{self.book.title}', collection_name='{self.collection.name}', date_added='{self.date_added}')>"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
first_name = db.Column(db.String(20))
last_name = db.Column(db.String(20))
gender = db.Column(db.String(20), nullable=False)
birth_date = db.Column(db.Date())
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
image_file = db.Column(db.String(20), nullable=False, default='default.jpg')
posts = db.relationship('Posts', backref='traveler', lazy='dynamic')
followed = db.relationship('Follow', foreign_keys=[Follow.follower_id], backref=db.backref('follower', lazy='joined'),
lazy='dynamic', cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
subscribes = db.relationship('Subscribe', foreign_keys=[Subscribe.user_id], backref=db.backref('subscriber', lazy='joined'),
lazy='dynamic', cascade='all, delete-orphan')
notifications = db.relationship('Notification', foreign_keys=[Notification.user_id], backref=db.backref('user', lazy='joined'),
lazy='dynamic', cascade='all, delete-orphan')
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
def follow(self, user):
if not self.is_following(user):
f = Follow(follower=self, followed=user)
db.session.add(f)
def unfollow(self, user):
f = self.followed.filter_by(followed_id=user.id).first()
if f:
db.session.delete(f)
def is_following(self, user):
if user.id is None:
return False
return self.followed.filter_by(
followed_id=user.id).first() is not None
def is_followed_by(self, user):
if user.id is None:
return False
return self.followers.filter_by(
follower_id=user.id).first() is not None
class Subscribe(db.Model):
id = db.Column(db.Integer, unique=True, primary_key=True)
post_id = db.Column(db.Integer,
db.ForeignKey('travel.id', ondelete='CASCADE'))
subscriber_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'))
notifications = db.relationship('Notification',
backref='subscribe',
cascade='all, delete-orphan',
passive_deletes=True)
follow_id = db.Column(db.Integer,
db.ForeignKey('follow.id', ondelete='CASCADE'),
nullable=False)
def to_json(self):
json_sub = {
'post_id':
self.post_id,
'subscriber_id':
self.subscriber_id,
'notifications': [{
'date': i.date_posted,
'id': i.id
} for i in self.notifications]
}
return json_sub
class Follow(db.Model):
id = db.Column(db.Integer, primary_key=True, unique=True)
follower_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
followed_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
subscribes = db.relationship('Subscribe',
backref='follow',
lazy='dynamic',
cascade='all, delete-orphan',
passive_deletes=True)
def to_json(self):
json_user = {
'follower_id': self.follower_id,
'followed_id': self.followed_id,
'follower_username': self.follower.username,
'followed_username': self.followed.username,
'follower_image': self.follower.image_file,
'followed_image': self.followed.image_file,
'subscribed_travels': len(self.subscribes.all())
}
return json_user
class State(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(25), nullable=False, unique=True)
counties = db.relationship('County', backref='county_state', lazy=True)
def __repr__(self):
return f"<State {self.id}: {self.name}>"
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(12), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default="default.jpg")
password = db.Column(db.String(60), nullable=False)
posts = db.relationship("Post", backref="author", lazy=True)
# Generate a token
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config["SECRET_KEY"], expires_sec)
return s.dumps({"user_id": self.id}).decode("utf-8")
# Verify the token and accept only a token (static decorator)
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config["SECRET_KEY"])
try:
user_id = s.loads(token)["user_id"]
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String, nullable=False)
last_name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False, unique=True)
password = db.Column(db.String, nullable=False)
approved = db.Column(db.Boolean, nullable=True)
check_in = db.Column(db.Boolean, nullable=True)
coach_id = db.Column(db.Integer, nullable=True)
access_token = db.Column(db.String, nullable=True)
role = db.Column(db.String, nullable=False)
verification_token = db.Column(db.String, nullable=True)
verified = db.Column(db.Boolean, nullable=False)
reset_token = db.Column(db.String, nullable=True)
album_id = db.Column(db.String, nullable=True)
album_deletehash = db.Column(db.String, nullable=True)
# 1 to many relationship with Client_templates
client_templates = db.relationship('ClientTemplate',
cascade="all, delete-orphan",
lazy='dynamic')
def encode_auth_token(self, sub):
"""
Generates the Auth Token
:sub: a dictionary containing any valid values
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=0, hours=2),
'iat':
datetime.datetime.utcnow(),
'sub':
sub
}
return jwt.encode(payload,
app.config.get('SECRET_KEY'),
algorithm='HS256').decode(encoding="utf-8")
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Expired'
except jwt.InvalidTokenError:
return 'Invalid'
class Clan(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_updated = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
tag = db.Column(db.String(20), nullable=False)
name = db.Column(db.String(50), nullable=False)
invite_type = db.Column(db.String(50), nullable=False)
description = db.Column(db.String(200), nullable=False)
location = db.Column(db.JSON, nullable=False)
badge_url = db.Column(db.JSON, nullable=False)
clan_level = db.Column(db.Integer, nullable=False)
clan_points = db.Column(db.Integer, nullable=False)
clan_versus_points = db.Column(db.Integer, nullable=False)
required_trophies = db.Column(db.Integer, nullable=True)
war_frequency = db.Column(db.Integer, nullable=False)
war_win_streak = db.Column(db.Integer, nullable=False)
war_wins = db.Column(db.Integer, nullable=False)
war_ties = db.Column(db.Integer, nullable=False)
war_losses = db.Column(db.Integer, nullable=False)
is_warlog_public = db.Column(db.Boolean, nullable=False)
war_league = db.Column(db.JSON, nullable=True)
member_count = db.Column(db.Integer, nullable=False)
labels = db.Column(db.JSON, nullable=True)
member_list = db.relationship('Clan_members_list',
backref="clan",
lazy=True)
class Conversation(db.Model):
conversation_id = db.Column(db.Integer, primary_key=True)
trainer_uuid = db.Column(db.String, unique=True, nullable=False)
user_uuid = db.Column(db.String, unique=True, nullable=False)
timestamp = db.Column(db.DateTime, default=datetime.datetime.now())
messages = db.relationship("Message")
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_by_trainer_uuid(cls, trainer_uuid):
return cls.query.filter_by(trainer_uuid=trainer_uuid).first()
@classmethod
def get_user_by_user_uuid(cls, user_uuid):
return cls.query.filter_by(user_uuid=user_uuid).first()
@classmethod
def get_all_messages(cls):
return Message.query.join(Conversation).all()
@classmethod
def does_exist(cls, trainer_uuid, user_uuid):
from backend.models.trainer import Trainer
trainer_conversation = Conversation.get_by_trainer_uuid(trainer_uuid)
user_conversation = Conversation.get_user_by_user_uuid(user_uuid)
if trainer_conversation.id is user_conversation.id:
return trainer_conversation
else:
return False
class Travel(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text, nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
start_date = db.Column(db.Date, nullable=False)
end_date = db.Column(db.Date, nullable=False)
country = db.Column(db.Text, nullable=False)
city = db.Column(db.Text, nullable=False)
latitude = db.Column(db.Float, nullable=False)
longitude = db.Column(db.Float, nullable=False)
content = db.Column(db.Text, nullable=False)
comment = db.Column(db.Text, nullable=False)
image_file = db.Column(db.Text,
nullable=False,
default="default_post.jpeg")
subscribers = db.relationship('Subscriptions',
backref='subscribers',
lazy='dynamic',
cascade='all, delete-orphan')
def update(self, data):
for attr in data:
setattr(self, attr, data[attr])
db.session.commit()
for sub in self.subscribers.all():
sub.send_notification()
def _repr_(self):
return f"Travel('{self.start_date}', '{self.end_date}', '{self.content}')"
