class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(150), nullable=False)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
login_count = db.Column(db.Integer)
current_login_ip = db.Column(db.String(255))
current_login_at = db.Column(db.DateTime, default=datetime.utcnow)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow)
posts = db.relationship('Post', backref='author', lazy='dynamic')
comments = db.relationship('Comment', backref='author', lazy='dynamic')
roles = db.relationship('Role', secondary=role_users, backref=db.backref('users', lazy="dynamic"),
cascade="save-update, merge, delete")
def __init__(self, email, password=None, *args, **kwargs):
super(User, self).__init__(email=email, password=password, *args, **kwargs)
if not self.username:
self.username = self.email.split("@")[0]
if not self.roles:
user_role = Role.query.filter(Role.name == 'user').first()
self.roles.append(user_role)
def __repr__(self):
return f'<User #{self.id} {self.email}>'
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(32), nullable=False)
last_name = db.Column(db.String(32))
password_hash = db.Column(db.String(120))
token = db.Column(db.String(130), nullable=False)
email = db.Column(db.String(130), nullable=False, unique=True)
contact_number = db.Column(db.String(12))
profile_url = db.Column(db.String(130))
about_me = db.Column(db.Text)
city = db.Column(db.String(32))
country = db.Column(db.String(32))
no_goals_added = db.Column(db.Integer)
no_goals_completed = db.Column(db.Integer)
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
user_goals = db.relationship('UserGoal', backref="user", cascade="all, delete-orphan", lazy='dynamic')
goal = db.relationship('Goal', backref="user", cascade="all, delete-orphan", uselist=False)
ug_likes = db.relationship('UserGoalLike', backref=db.backref('user', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
g_likes = db.relationship('GoalLike', backref=db.backref('user', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
class Goal(db.Model):
__tablename__ = 'goal'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
name = db.Column(db.String(256), nullable=False)
cat_id = db.Column(db.Integer, default=1)
image_url = db.Column(db.String(130))
no_added = db.Column(db.Integer, default=1)
no_completed = db.Column(db.Integer, default=0)
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
user_goals = db.relationship('UserGoal', backref="goal", cascade="all, delete-orphan", lazy='dynamic')
g_likes = db.relationship('GoalLike', backref=db.backref('goal', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
@property
def serialize(self):
return {
'id': self.id,
'user_id': self.user_id,
'first_name': self.user.first_name,
'last_name': self.user.last_name,
'name': self.name,
'cat_id': self.cat_id,
'image_url': self.image_url,
'no_added': self.no_added,
'no_completed': self.no_completed,
'created_at': self.created_at,
'updated_at': self.updated_at
}
class User(db.Model):
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(80))
last_name = db.Column(db.String(80))
email = db.Column(db.String(80))
picture = db.Column(db.String(120))
age_range = db.Column(db.String(80))
fb_token = db.Column(db.String(120))
gender = db.Column(db.Integer)
reg_date = db.Column(db.DateTime)
posts = db.relationship('Post', backref='publisher', lazy='dynamic')
subscribed_groups = db.relationship('Group',
secondary=subscribe,
backref=db.backref('subscribers',
lazy='dynamic'))
banned_from = db.relationship('Group',
secondary=ban,
backref=db.backref('banned_users',
lazy='dynamic'))
admin_of = db.relationship('Group')
def __init__(self, first_name, last_name, email, picture, age_range,
fb_token, gender):
self.first_name = first_name
self.last_name = last_name
self.email = email
self.picture = picture
self.age_range = age_range
self.fb_token = fb_token
self.gender = gender
self.reg_date = datetime.now()
def __repr__(self):
return '<User %r>' % self.user_id
def get_subscribed_groups(self, user_id, page=0): # -> group_id []
user = User.query.filter(User.user_id == user_id).first()
return [group.group_id for group in user.subscribed_groups]
def subscribe_to(self, group_id, user_id, is_submitter): # -> bool
subscribe.insert().values(group_id=group_id,
user_id=user_id,
is_submitter=is_submitter,
time=datetime.now())
db.session.commit()
return True
def ban_user(self, group_id, admin_id, banned_by, is_shadow): # -> bool
ban.insert().values(group_id=group_id,
admin_id=admin_id,
banned_by=banned_by,
is_shadow=is_shadow,
time=datetime.now())
db.session.commit()
return True
class Post(db.Model):
post_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
message = db.Column(db.String(5000))
url = db.Column(db.String(120))
settings = db.Column(db.SmallInteger)
publish_date = db.Column(db.DateTime)
publisher_id = db.Column(db.Integer, db.ForeignKey('user.user_id'))
group_id = db.Column(db.Integer, db.ForeignKey('group.group_id'))
seen_by = db.relationship('User', secondary=seen)
comments = db.relationship('Comment', backref='post', lazy='dynamic')
#backrefs
#publisher -> submitted by
#group -> submitted in
def __init__(self, post):
self.message = post.message
self.url = post.url
self.settings = post.settings
self.publisher_id = post.publisher_id
self.group_id = post.group_id
self.publish_date = datetime.now()
def __repr__(self):
return '<Post %r>' % self.post_id
def get_hot_feed(self, group_id, page=0): # -> post_id[]
group = Group.query.filter(Group.group_id == group_id).first()
return [post.post_id for post in group.posts]
def get_trending_feed(self, group_id, page=0): # -> post_id[]
group = Group.query.filter(Group.group_id == group_id).first()
return [post.post_id for post in group.posts]
def get_new_feed(self, group_id, page=0): # -> post_id[]
group = Group.query.filter(Group.group_id == group_id).first()
return [post.post_id for post in group.posts]
def get_post(self, post_id): # -> post
return Post.query.filter(Post.post_id == post_id).first()
def create_post(self, post): # -> post_id
temp = Post(post)
db.session.add(temp)
db.commit()
return temp.post_id
def get_front_page(self, user_id): # -> post_id []
user = User.query.filter(User.user_id == user_id).first()
result = []
for group in user.subscribed_groups:
result.append([post.post_id for post in group.posts])
return result
class Venue(db.Model):
__tablename__ = 'venues'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(), nullable=False)
city = db.Column(db.String(120))
state = db.Column(db.String(10))
address = db.Column(db.String(120))
phone = db.Column(db.String(30))
image_link = db.Column(db.String(500))
facebook_link = db.Column(db.String(120))
website = db.Column(db.String(120))
seeking_talent = db.Column(db.Boolean, default=False)
seeking_description = db.Column(db.String())
genres = db.relationship('Genre',
secondary=venue_genre,
backref='venues',
lazy=True)
shows = db.relationship('Show',
backref='venue',
cascade=['all'],
lazy=True)
def __repr__(self):
return f"<Venue id={self.id} name={self.name}>"
def venue_to_dictionary(self):
data = {
"id":
self.id,
"name":
self.name,
"address":
self.address,
"city":
self.city,
"state":
self.state,
"phone":
self.phone,
"website":
self.website,
"facebook_link":
self.facebook_link,
"seeking_talent":
self.seeking_talent,
"seeking_description":
self.seeking_description,
"image_link":
self.image_link,
"genres":
[g.description for g in sorted(self.genres, key=lambda a: a.id)]
}
return data
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
full_name = db.Column(db.String(30))
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.Text, nullable=False)
access_level = db.Column(db.Integer,
db.ForeignKey('access_levels.id'),
default=0)
favorite_quotes = db.relationship('FavoriteQuote',
backref='favorite_quotes')
access_level_name = db.relationship('AccessLevel', backref='access_levels')
class User(db.Model):
uid = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True)
password_hash = db.Column(db.String(144))
timelines = db.relationship('Timeline', backref='owner', lazy='joined')
def __init__(self, username, password):
self.username = username
self.password_hash = generate_password_hash(password, method='sha512')
@classmethod
def authenticate(cls, username, password):
"""Authenticates details of a user
Parameters
----------
username : str
The username of the user to authenticate
password : str
The password to authenticate with
Returns
-------
User
The authenticated user
"""
if any(i is None for i in (username, password)):
return dict(error='missing fields'), 400
user = cls.query.filter_by(username=username).first()
if user is None or not check_password_hash(user.password_hash, password):
return dict(error='incorrect credentials or user doesn\'t exist'), 401
else:
token = create_access_token(identity=user)
return dict(username=user.username, token=token), 200
class Subscription(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
device = db.Column(db.VARCHAR(40), nullable=False)
service_id = db.Column(INTEGER(unsigned=True),
db.ForeignKey('service.id'),
nullable=False)
service = db.relationship('Service',
backref=db.backref('subscription',
lazy='dynamic'))
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
timestamp_checked = db.Column(db.TIMESTAMP)
def __init__(self, device, service):
self.device = device
self.service = service
self.timestamp_checked = datetime.utcnow() - timedelta(minutes=30)
def __repr__(self):
return '<Subscription %r>' % self.id
def messages(self):
return Message.query \
.filter_by(service_id=self.service_id) \
.filter(Message.timestamp_created > self.timestamp_checked)
def as_dict(self):
data = {
"uuid": self.device,
"service": self.service.as_dict(),
"timestamp": int(self.timestamp_created.strftime('%s')),
"timestamp_checked": int(self.timestamp_checked.strftime('%s'))
}
return data
class Users(db.Model, UserMixin):
__tablename__ = 'users'
# Primary key
id = db.Column(db.Integer, primary_key=True)
# Columns
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())
roles = db.relationship('Roles', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
# Representation
def __repr__(self):
return '<id %r>' % self.id
# Check if a user email exists
@classmethod
def check_user(class_, email):
Users = class_
# Query for the email
user = Users.query.filter_by(email=email).first()
# Return true if exists
if user:
return user
else:
return False
class Subscription(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
device = db.Column(db.VARCHAR(40), nullable=False)
service_id = db.Column(INTEGER(unsigned=True), db.ForeignKey('service.id'), nullable=False)
service = db.relationship('Service', backref=db.backref('subscription', lazy='dynamic'))
last_read = db.Column(INTEGER(unsigned=True), db.ForeignKey('message.id'), default=0)
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
timestamp_checked = db.Column(db.TIMESTAMP)
def __init__(self, device, service):
last_message = Message.query.order_by(Message.id.desc()).first()
self.device = device
self.service = service
self.timestamp_checked = datetime.utcnow()
self.last_read = last_message.id if last_message else 0
def __repr__(self):
return '<Subscription {}>'.format(self.id)
def messages(self):
return Message.query \
.filter_by(service_id=self.service_id) \
.filter(Message.id > self.last_read)
def as_dict(self):
data = {
"uuid": self.device,
"service": self.service.as_dict(),
"timestamp": int((self.timestamp_created - datetime.utcfromtimestamp(0)).total_seconds()),
"timestamp_checked": int((self.timestamp_checked - datetime.utcfromtimestamp(0)).total_seconds())
}
return data
class Booking(db.Model):
__tablename__ = 'mimir_bookings'
identifier = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), unique=False, nullable=False)
start = db.Column(db.DateTime, nullable=False, default=datetime.now)
end = db.Column(db.DateTime, nullable=False, default=datetime.now)
cell_colour = db.Column(db.String(255), unique=False, nullable=False)
timetable_id = db.Column(db.Integer,
db.ForeignKey('mimir_timetables.identifier'))
timetable = db.relationship('Timetable', back_populates="bookings")
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
@property
def duration(self):
return abs(self.end - self.start).total_seconds() / 3600
@property
def timetable_name(self):
if timetable is not None:
return timetable.name
return "Not Set"
@property
def serialize(self):
return {
'id': self.identifier,
'booking': self.name,
'timetable': self.timetable.name,
'timetable_id': self.timetable_id,
'start_time': self.start,
'end_time': self.end,
'duration': self.duration,
'cell_colour': self.cell_colour
}
class Room(db.Model):
__tablename__ = "rooms"
id = db.Column("room_id", db.Integer, primary_key=True)
info = db.Column("info", db.String(), nullable=True)
name = db.Column("name", db.String(50), nullable=False)
seats = db.relationship('Seat',
back_populates="room",
cascade="all, delete")
def __init__(self, name, info):
self.name = name
self.info = info
def get_seat_list(self):
seat_list = list(map(lambda x: x.to_json(), self.seats))
sorted_seat_list = sorted(seat_list, key=lambda x: x['id'])
return sorted_seat_list
def to_json(self):
return {
"id": self.id,
"name": self.name,
"info": self.info,
"seats": {
"count": len(self.seats),
"seats": self.get_seat_list(),
},
}
def __str__(self):
return str(self.__class__) + ":" + str(self.__dict__)
class Message(db.Model):
id = db.Column(INTEGER(unsigned=True), primary_key=True)
service_id = db.Column(INTEGER(unsigned=True),
db.ForeignKey('service.id'),
nullable=False)
service = db.relationship('Service',
backref=db.backref('message', lazy='dynamic'))
text = db.Column(db.TEXT, nullable=False)
title = db.Column(db.VARCHAR)
level = db.Column(TINYINT, nullable=False, default=0)
link = db.Column(db.TEXT, nullable=False, default='')
timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow)
def __init__(self, service, text, title=None, level=0, link=''):
self.service = service
self.text = text
self.title = title
self.level = level
self.link = link
def __repr__(self):
return '<Message %r>' % self.id
def as_dict(self):
return {
"service": self.service.as_dict(),
"message": self.text,
"title": self.title,
"link": self.link,
"level": self.level,
"timestamp": int(self.timestamp_created.strftime('%s'))
}
class Post(db.Model):
from models import User, Category
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(140), nullable=False)
slug = db.Column(db.String(140), nullable=False, unique=True)
text = db.Column(db.Text, nullable=False)
photo = db.Column(db.String(255), unique=True)
is_published = db.Column(db.Boolean,
nullable=False,
default=False,
server_default='0')
user_id = db.Column(db.Integer,
db.ForeignKey(User.id,
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=False)
category_id = db.Column(db.Integer,
db.ForeignKey(Category.id,
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
published_at = db.Column(db.DateTime, default=datetime.now())
tags = db.relationship('Tag',
secondary=post_tags,
backref=db.backref('posts', lazy="dynamic"))
comments = db.relationship('Comment',
secondary=post_comments,
backref=db.backref('post', lazy="dynamic"))
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.title:
self.slug = slugify(self.title)
def is_owner(self):
return self.author == current_user
def __repr__(self):
return f'<Post #{self.id} {self.title}>'
class Room(db.Model):
__tablename__ = 'heimdall_rooms'
identifier = db.Column(db.Integer, primary_key=True)
room_name = db.Column(db.String(255), unique=False, nullable=False)
subnets = db.Column(db.String(255), unique=False, nullable=False)
capacity = db.Column(db.Integer, unique=False, nullable=False, default=0)
has_availability_map = db.Column(db.Boolean,
unique=False,
nullable=False,
default=False)
desks = db.relationship(
'Desk', back_populates='room') ## Link the Room to the desks
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
def __init__(self, **kwargs):
## Default constructor handling by SQLAlchemy ORM
super(Room, self).__init__(**kwargs)
## Custom constructor code
self.validateSubnets()
@property
def serialize(self):
return {
'id': self.identifier,
'name': self.room_name,
'subnets': self.subnets,
'capacity': self.capacity,
'number_of_desks': len(self.desks),
'number_of_computers': self.computer_count,
'has_availability_map': self.has_availability_map
}
@property
def computer_count(self):
## Check the Room has desks
if self.desks is None:
return 0
## Count the computers
computerCount = 0
for desk in self.desks:
if desk.computers is not None:
computerCount += len(desk.computers)
return computerCount
def validateSubnets(self):
## Check the subnet is a valid format
suppliedSubnets = self.subnets.split(
',') ## Split into each of the supplied subnets
for subnet in suppliedSubnets:
subnetSections = subnet.split('.')
## Check the subnet was composed of 3 sections, e.g. 192.168.0. Subnets with trailing '.' will also be marked as invalid
if len(subnetSections) != 3:
self.subnets = "Invalid"
for section in subnetSections:
## check the subnet section is not longer than 3 characters
if len(section) > 3:
self.subnets = "Invalid"
class List(db.Model):
__tablename__ = "list"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.ForeignKey('user.id'))
name = db.Column(db.String(128), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
goals = db.relationship('UserGoal', backref="list", lazy='dynamic')
class Timeline(db.Model):
uid = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(32))
owner_id = db.Column(db.Integer, db.ForeignKey('user.uid'))
nodes = db.relationship('TimelineNode', backref='timeline', lazy='joined', order_by='TimelineNode.position')
@property
def next_node(self):
return len(self.nodes)
class Character(db.Model):
__tablename__ = 'characters'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True, nullable=False)
house_id = db.Column(db.Integer, db.ForeignKey('houses.id'))
image_url_full = db.Column(db.Text)
image_url_thumb = db.Column(db.Text)
quotes = db.relationship('Quote', backref='quotes')
class Question(db.Model, JsondModel):
__tablename__ = 'questions'
external_attrs = ['title', 'prompt']
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String())
prompt = db.Column(db.Text)
responses = db.relationship('Response', backref='question', lazy='dynamic')
categories = db.relationship('Category',
backref='question',
lazy='dynamic')
def __init__(self, title, prompt):
self.title = title
self.prompt = prompt
def __repr__(self):
return '<id {}>'.format(self.id)
class Desk(db.Model):
__tablename__ = 'heimdall_desks'
identifier = db.Column(db.Integer, primary_key=True)
desk_id = db.Column(db.String(255), unique=False, nullable=False)
room_id = db.Column(
db.Integer,
db.ForeignKey("heimdall_rooms.identifier")) ## Foreign Key to the room
room = db.relationship(
'Room', back_populates="desks") ## Link to a Room (many-to-1)
computers = db.relationship(
'Computer', back_populates='desk'
) ## Link to a desk to multiple computers (1-to-many)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
@property
def serialize(self):
return {
'id': self.identifier,
'name': self.desk_id,
'room': self.get_room,
'room_id': self.room_id,
'number_of_computers': len(self.computers),
'computers': self.get_computers
}
@property
def get_room(self):
if self.room is not None:
return self.room.room_name
return "Not Set"
@property
def get_computers(self):
if self.computers is None:
return []
else:
computers = []
for computer in self.computers:
computers.append(computer.trimmed_serialize)
return computers
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(
PasswordType(schemes=['pbkdf2_sha512', ])
)
documents = db.relationship('Document', backref="user", lazy=True)
surveydata = db.Column(db.String(5000), nullable=True)
current_experiment_index = db.Column(db.Integer, default=0)
def __repr__(self):
return '<User %r>' % self.username
class Content(db.Model):
## The different fields of the model, these generate the table columns
__tablename__ = 'yggdrasil_content'
identifier = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
name = db.Column(db.String(255), unique=False, nullable=False)
carousel_id = db.Column(db.Integer,
db.ForeignKey("yggdrasil_carousels.identifier"))
carousel = db.relationship('Carousel', back_populates="content")
content_type = db.Column(db.String(255), unique=False, nullable=False)
content_location = db.Column(db.String(255), unique=False, nullable=False)
slide_interval = db.Column(db.Integer, unique=False,
nullable=False) # in milliseconds
is_enabled = db.Column(db.Boolean,
unique=False,
nullable=False,
default=True)
def __init__(self, **kwargs):
## Default constructor handling by SQLAlchemy ORM
super(Content, self).__init__(**kwargs)
## Custom constructor code
self.validateContentType()
## Serialise the model instance ready for jsonification
@property
def serialize(self):
return {
'id': self.identifier,
'name': self.name,
'carousel': self.carousel_name,
'carousel_id': self.carousel_id,
'type': self.content_type,
'location': self.content_location,
'interval': self.slide_interval,
'is_enabled': self.is_enabled
}
## Function for grabbing the name of the carousel this content item is attached to
@property
def carousel_name(self):
if self.carousel is not None:
if self.carousel.name is not None:
return self.carousel.name
return "Not Set"
def validateContentType(self):
validTypes = ['picture', 'video', 'webpage', 'heimdall', 'mimir']
if self.content_type not in validTypes:
self.content_type = 'invalid'
class Seat(db.Model):
__tablename__ = "seats"
id = db.Column("seat_id", db.Integer, primary_key=True)
room_id = db.Column(
db.ForeignKey("rooms.room_id"),
nullable=False,
)
seat_name = db.Column("seat_name", db.String(10), unique=False)
room = db.relationship("Room", uselist=False, back_populates="seats")
info = db.Column("info", db.String(), nullable=True)
application = db.relationship("Application",
uselist=False,
back_populates="seat")
def __init__(self, name, room, info):
self.seat_name = name
self.room = room
self.info = info
def to_json(self, refer_user=True):
seatDict = {
"id": self.id,
"name": self.seat_name,
"info": self.info,
"roomId": self.room.id,
}
if refer_user:
seatDict["user"] = self.application.user.to_json(
) if self.application else None
return seatDict
def __str__(self):
return str(self.__class__) + ":" + str(self.__dict__)
class Author(db.Model):
__tablename__ = 'authors'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
books = db.relationship('Book', backref='author', lazy='dynamic')
def __init__(self, name):
self.name = name
def __repr__(self):
return 'id:{} name: {}'.format(self.id, self.name)
class Class(db.Model):
__tablename__ = 'classes'
id = db.Column(db.Integer, primary_key=True)
size = db.Column(db.Integer, nullable=False)
wod = db.Column(db.Text)
type_id = db.Column(db.Integer, db.ForeignKey('class_types.id'))
sessions = db.relationship('ClassSession',
backref='classes',
lazy='dynamic')
type = db.relationship("ClassType",
primaryjoin='ClassType.id==Class.type_id')
def __init__(self, size, wod, type_id):
self.size = size
self.type_id = type_id
self.wod = wod
def __str__(self):
return "Class"
class ClassSession(db.Model):
__tablename__ = "class_sessions"
id = db.Column(db.Integer, primary_key=True)
class_id = db.Column(db.Integer, db.ForeignKey('classes.id'))
dateTime = db.Column(db.Date, nullable=False)
coach_id = db.Column(db.Integer, db.ForeignKey('athletes.id'))
coach = db.relationship('Athlete',
primaryjoin='Athlete.id==ClassSession.coach_id')
def __init__(self, dateTime, coach_id):
self.coach_id = coach_id
self.dateTime = dateTime
class SuccessStory(db.Model):
__tablename__ = "successstory"
id = db.Column(db.Integer, primary_key=True)
user_goal_id = db.Column(db.ForeignKey('usergoal.id'))
story = db.Column(db.Text)
lat = db.Column(db.Float)
long = db.Column(db.Float)
date_completed = db.Column(db.DateTime)
likes = db.Column(db.Integer, default=0)
image_url = db.Column(db.String(130))
video_url = db.Column(db.String(130))
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
ss_likes = db.relationship('SuccessStoryLike', backref=db.backref('successstory', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
class UserGoal(db.Model):
__tablename__ = 'usergoal'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
goal_id = db.Column(db.Integer, db.ForeignKey('goal.id'))
likes = db.Column(db.Integer, default=0)
lat = db.Column(db.Float)
long = db.Column(db.Float)
date_target = db.Column(db.DateTime)
privacy = db.Column(db.SmallInteger)
list_id = db.Column(db.ForeignKey('list.id'))
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
ug_likes = db.relationship('UserGoalLike', backref=db.backref('usergoal', lazy='joined'), lazy='dynamic',
cascade="all, delete, delete-orphan")
class Category(db.Model):
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
slug = db.Column(db.String(100), nullable=False, unique=True)
posts = db.relationship('Post', backref='category', lazy='dynamic')
def __init__(self, *args, **kwargs):
super(Category, self).__init__(*args, **kwargs)
self.slug = slugify(self.name)
def __repr__(self):
return f'<Category #{self.id} {self.name}>'
