class Committee(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
posts = db.relationship("CommitteePost", back_populates="committee")
events = db.relationship("Event", back_populates="committee")
logo = db.Column(db.String)
description = db.Column(db.String)
facebook_url = db.Column(db.String)
instagram_url = db.Column(db.String)
page_id = db.Column(db.Integer, db.ForeignKey("page.id"))
page = db.relationship("Page", back_populates="committee")
category_id = db.Column(db.Integer, db.ForeignKey('CommitteeCategory.id'))
category = db.relationship("CommitteeCategory")
def to_dict(self):
posts = [post.to_dict() for post in self.posts]
events = [event.to_dict() for event in self.events]
if self.page != None:
page = self.page.to_dict()
else:
page = None
return {
"id": self.id,
"name": self.name,
"posts": sorted(posts, key=lambda p: p["weight"], reverse=True),
"logo": self.logo,
"description": self.description,
"facebookUrl": self.facebook_url if not RECEPTION_MODE else None,
"instagramUrl": self.instagram_url if not RECEPTION_MODE else None,
"page": page,
"events": events,
}
def to_dict_without_page(self):
posts = [post.to_dict() for post in self.posts]
events = [event.to_dict() for event in self.events]
return {
"id": self.id,
"name": self.name,
"posts": sorted(posts, key=lambda p: p["weight"], reverse=True),
"logo": self.logo,
"description": self.description,
"facebookUrl": self.facebook_url if not RECEPTION_MODE else None,
"instagramUrl": self.instagram_url if not RECEPTION_MODE else None,
"events": events,
}
def to_basic_dict(self):
return {
"id": self.id,
"name": self.name,
"logo": self.logo,
"description": self.description,
"facebookUrl": self.facebook_url if not RECEPTION_MODE else None,
"instagramUrl": self.instagram_url if not RECEPTION_MODE else None,
"pageSlug": self.page.slug if self.page else None
}
class MessageModel(db.Model):
__tablename__ = "messages"
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.String(140))
sender_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
recipient_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
nullable=False)
recipient = db.relationship("UserModel", foreign_keys=[recipient_id])
sender = db.relationship("UserModel", foreign_keys=[sender_id])
def save_to_db(self):
db.session.add(self)
db.session.commit()
def json(self):
return {
"id": self.id,
"message": self.message,
"sender_id": self.sender_id,
"recipient_id": self.recipient_id,
}
@classmethod
def find_recent_from(cls, recipient_id, sender_id):
return (cls.query.filter_by(
sender_id=sender_id, recipient_id=recipient_id).limit(100).all())
@classmethod
def find_recent(cls, recipient_id):
return cls.query.filter_by(recipient_id=recipient_id).limit(100).all()
class Event(db.Model):
__tablename__ = "event"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
title = db.Column(db.String, nullable=False)
title_en = db.Column(db.String, nullable=True)
date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
scheduled_date = db.Column(db.DateTime, default=None, nullable=True)
draft = db.Column(db.Boolean, default=False)
body = db.Column(db.Text, nullable=False)
body_en = db.Column(db.Text, nullable=True)
location = db.Column(db.String)
committee_id = db.Column(db.Integer, db.ForeignKey('committee.id'))
committee = db.relationship("Committee", back_populates="events")
header_image = db.Column(
db.String, default="static/posts/default.png"
) #can be changed if we get a default event picture
tags = db.relationship("PostTag", secondary=events_tags)
facebook_link = db.Column(db.String)
event_date = db.Column(db.DateTime, default=datetime.datetime.utcnow())
end_date = db.Column(db.DateTime,
default=datetime.datetime.utcnow() +
datetime.timedelta(hours=5))
def to_dict(self):
com = None
if self.committee:
com = self.committee.to_basic_dict()
return {
"id": self.id,
"user_id": self.user_id,
"title": {
"se": self.title,
"en": self.title_en
},
"date": self.date,
"scheduled_date": self.scheduled_date,
"draft": self.draft,
"body": {
"se": self.body,
"en": self.body_en
},
"location": self.location,
"header_image": self.header_image,
"committee": com,
"tags": [t.to_dict() for t in self.tags],
"facebook_link": self.facebook_link,
"event_date": self.event_date,
"end_date": self.end_date
}
class Review(db.Model):
"""Class to create a Review class object"""
__tablename__ = 'reviews'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(256), nullable=False)
business = db.Column(db.Integer, db.ForeignKey('businesses.id'))
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime, default=db.func.current_timestamp(
), onupdate=db.func.current_timestamp())
author = db.relationship("User")
def __init__(self, name, description, business):
self.name = name
self.description = description
self.business = business
self.created_by = session["user_id"]
def __repr__(self):
return '<Review: {}>'.format(self.name)
def review_as_dict(self):
"""Represent the review as a dict"""
review = {r.name: getattr(self, r.name) for r in self.__table__.columns}
review['author'] = self.author.first_name + ' ' + self.author.last_name
return review
class Log(db.Model):
"""Class for database changes logs"""
__tablename__ = 'logs'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
action = db.Column(db.String(50), nullable=False)
message = db.Column(db.String(256), nullable=False)
table = db.Column(db.String(50), nullable=False)
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
author = db.relationship("User")
def __init__(self, action, message, table, user_id):
self.action = action
self.message = message
self.table = table
self.created_by = user_id
def __repr__(self):
return '<Log: {}>'.format(self.message)
def log_as_dict(self):
"""Represent the log as a dict"""
log = {l.name: getattr(self, l.name) for l in self.__table__.columns}
log['author'] = self.author.first_name + ' ' + self.author.last_name
return log
class User(UserMixin, db.Model):
"""Class to create a User class object"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(50), nullable=False)
last_name = db.Column(db.String(50), nullable=False)
username = db.Column(db.String(50), nullable=False, unique=True)
password_hash = db.Column(db.String(256), nullable=False)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
businesses = db.relationship('Business',
order_by='Business.id',
cascade='all, delete-orphan')
def __init__(self, first_name, last_name, username, password):
self.first_name = first_name
self.last_name = last_name
self.username = username
self.password_hash = generate_password_hash(password)
def __repr__(self):
return '<User: {}>'.format(self.username)
def user_as_dict(self):
"""Represent the user as a dict"""
return {u.name: getattr(self, u.name) for u in self.__table__.columns}
class Category(db.Model):
"""Class to create a Category class object"""
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(256), nullable=False)
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
author = db.relationship("User")
def __init__(self, name, description):
self.name = name
self.description = description
self.created_by = session["user_id"]
def __repr__(self):
return '<Category: {}>'.format(self.name)
def category_as_dict(self):
"""Represent the category as a dict"""
category = {
c.name: getattr(self, c.name)
for c in self.__table__.columns
}
category[
'author'] = self.author.first_name + ' ' + self.author.last_name
return category
class Business(db.Model):
"""Class to create a Business class object"""
__tablename__ = 'businesses'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), unique=True, nullable=False)
description = db.Column(db.String(256), nullable=False)
category = db.Column(db.Integer, db.ForeignKey('categories.id'))
location = db.Column(db.Integer, db.ForeignKey('locations.id'))
photo = db.Column(db.String(256))
created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
reviews = db.relationship('Review',
order_by='Review.id',
cascade='all, delete-orphan')
author = db.relationship("User")
category_relationship = db.relationship("Category")
location_relationship = db.relationship("Location")
def __init__(self, name, description, category, location, photo):
self.name = name
self.description = description
self.category = category
self.location = location
self.photo = photo
self.created_by = session["user_id"]
def __repr__(self):
return '<Business: {}>'.format(self.name)
def business_as_dict(self):
"""Represent the business as a dict"""
business = {
b.name: getattr(self, b.name)
for b in self.__table__.columns
}
business[
'author'] = self.author.first_name + ' ' + self.author.last_name
business['category_name'] = self.category_relationship.name
business['location_name'] = self.location_relationship.name
return business
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())
roles = db.relationship("Role",
secondary=roles_users,
backref=db.backref("users", lazy="dynamic"))
class CommitteePostTerm(db.Model):
__tablename__ = "committee_post_term"
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer, db.ForeignKey('committee_post.id'))
post = db.relationship("CommitteePost", back_populates="terms")
start_date = db.Column(db.DateTime)
end_date = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship("User", back_populates="post_terms")
def to_dict(self):
return {
"id": self.id,
"startDate": self.start_date.strftime("%Y-%m-%d"),
"endDate": self.end_date.strftime("%Y-%m-%d"),
"post": self.post.to_dict_without_terms(),
"user": self.user.to_dict_without_terms(),
"isCurrent": self.start_date < datetime.now() < self.end_date
}
class ArticleModel(db.Model, CRUDMixin):
__tablename__ = 'api_article'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
description = db.Column(db.Text)
categories = db.relationship('CategoryModel', secondary=api_category_article, lazy='subquery',
backref=db.backref('articles', lazy=True))
def __repr__(self):
return '<id {}>'.format(self.id)
class Album(db.Model):
__tablename__ = "albums"
albumId = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
creationDate = db.Column(db.DateTime, default=datetime.datetime.now)
lastEdit = db.Column(db.DateTime, default=datetime.datetime.now)
receptionAppropriate = db.Column(db.Boolean)
images = db.relationship("Image", secondary=imageAssociation)
videos = db.relationship("Video", secondary=video_playlist_table)
date = db.Column(db.DateTime)
def to_dict(self):
return {
"id": self.albumId,
"title": self.title,
"creationDate": self.creationDate,
"lastEdit": self.lastEdit,
"receptionAppropriate": self.receptionAppropriate,
"images": [image.to_dict() for image in self.images],
"videos": [video.to_dict() for video in self.videos],
"date": self.date
}
class CommitteeCategory(db.Model):
__tablename__ = 'CommitteeCategory'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False, unique=True)
email = db.Column(db.String, nullable=True)
weight = db.Column(db.Integer, default=1)
committees = db.relationship("Committee")
def to_dict(self):
return {
"id": self.id,
"title": self.title,
"email": self.email,
"weight": self.weight
}
class Video(db.Model):
__tablename__ = 'video'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
mux_asset_id = db.Column(db.String)
mux_playback_id = db.Column(db.String)
uploaded_at = db.Column(db.DateTime, default=datetime.datetime.now)
requires_login = db.Column(db.Boolean, default=False)
albums = db.relationship("Album", secondary=video_playlist_table)
def to_dict(self):
return {
"id": self.id,
"title": self.title,
"url": "https://stream.mux.com/" + self.mux_playback_id + ".m3u8",
"thumbnail":
"https://image.mux.com/" + self.mux_playback_id + "/thumbnail.jpg",
"uploadedAt": self.uploaded_at,
"requiresLogin": self.requires_login,
"albums": [album.albumId for album in self.albums]
}
class PageRevision(db.Model):
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.datetime.now)
revision_type = db.Column(db.Enum(PageRevisionType))
author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
author = db.relationship("User")
title_sv = db.Column(db.String)
title_en = db.Column(db.String)
content_sv = db.Column(db.String)
content_en = db.Column(db.String)
image = db.Column(db.String)
page_id = db.Column(db.Integer, db.ForeignKey("page.id"))
published = db.Column(db.Boolean, default=False)
def to_dict(self):
return {
"id":
self.id,
"timestamp":
self.timestamp,
"type":
self.revision_type.name,
"author":
self.author.to_dict_without_terms()
if self.author != None else None,
"title_sv":
self.title_sv,
"title_en":
self.title_en,
"image":
self.image if not RECEPTION_MODE else None,
"content_sv":
self.content_sv,
"content_en":
self.content_en,
"published":
self.published
}
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
title_en = db.Column(db.String, nullable=True)
date = db.Column(db.DateTime, default=datetime.utcnow)
scheduled_date = db.Column(db.DateTime, default=None, nullable=True)
draft = db.Column(db.Boolean, default=False)
header_image = db.Column(
db.String,
default="https://api.medieteknik.com/static/posts/default.png")
body = db.Column(db.String, nullable=False)
body_en = db.Column(db.String, nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
committee_id = db.Column(db.Integer,
db.ForeignKey("committee.id"),
nullable=True)
tags = db.relationship("PostTag", secondary=posts_tags)
def to_dict(self):
return {
"id": self.id,
"title": {
"se": self.title,
"en": self.title_en
},
"date": self.date,
"scheduled_date": self.scheduled_date,
"draft": self.draft,
"header_image": self.header_image,
"body": {
"se": self.body,
"en": self.body_en
},
"user_id": self.user_id,
"committee_id": self.committee_id,
"tags": [tag.id for tag in self.tags]
}
class Document(db.Model):
__tablename__ = "documents"
itemId = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
title_en = db.Column(db.String)
tags = db.relationship("DocumentTags")
date = db.Column(db.Date, nullable=False)
fileName = db.Column(db.String)
thumbnail = db.Column(db.String)
def to_dict(self):
return {
"id": self.itemId,
"title": {
"se": self.title,
"en": self.title_en
},
"tags": [res.tagId for res in self.tags],
"fullTags": [res.serialize() for res in self.tags],
"filename": self.fileName,
"date":
self.date.strftime("%Y-%m-%d") if self.date is not None else None,
"thumbnail": self.thumbnail
}
class Page(db.Model):
id = db.Column(db.Integer, primary_key=True)
slug = db.Column(db.String, unique=True)
committee = db.relationship("Committee",
back_populates="page",
uselist=False)
revisions = db.relationship("PageRevision",
backref="page",
order_by=lambda: PageRevision.timestamp.desc())
def latest_published_revision(self):
return next(
(revision for revision in self.revisions if revision.published),
None)
def is_editable_by(self, user):
if self.committee == None:
return False
for term in user.post_terms:
committee_id = term.post.committee_id
if self.committee.id == committee_id:
return True
return False
def to_dict(self):
current = self.latest_published_revision()
published = current != None
committee = self.committee.to_dict_without_page(
) if self.committee != None else None
if published:
title_sv = current.title_sv
title_en = current.title_en
content_sv = current.content_sv
content_en = current.content_en
image = current.image
author = current.author.to_dict(
) if current.author != None else None
updated = current.timestamp
else:
title_sv = None
title_en = None
content_sv = None
content_en = None
image = None
author = None
updated = None
return {
"id": self.id,
"slug": self.slug,
"committee": committee,
"title_sv": title_sv,
"title_en": title_en,
"content_sv": content_sv,
"content_en": content_en,
"image": image if not RECEPTION_MODE else None,
"author": author,
"revisions": [revision.to_dict() for revision in self.revisions],
"published": published,
"updated": updated
}
class User(db.Model):
__tablename__ = 'User'
id = db.Column(db.String(100), primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(100))
email = db.Column(db.String(100))
photoURL = db.Column(db.String, default=_photoURL)
allowed_usage = db.Column(db.Integer)
ftl = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
deleted_at = db.Column(db.DateTime, nullable=True)
files = db.relationship('File', backref='uploader')
badges = db.relationship('Badges', backref='creator')
permissions = db.relationship('Permissions',
backref=db.backref('user_permissions'),
lazy='dynamic')
siteAdmin = db.Column(db.Boolean, default=False)
last_login_ip = db.Column(db.String, nullable=True)
last_login_date = db.Column(db.DateTime, nullable=True)
def __init__(self, id_, username, password, email, photoURL=None):
self.id = id_
self.username = username
self.allowed_usage = 200
if password:
self.password = generate_password_hash(password)
self.email = email
if photoURL:
self.photoURL = photoURL
def create_site_admin(self):
self.siteAdmin = True
self.save_to_db()
def save_to_db(self):
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
def delete_user(self):
db.session.delete(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
@classmethod
def getUser(cls, user_id=None, username=None, email=None):
if user_id:
return cls.query.filter_by(id=user_id).first()
if username:
return cls.query.filter_by(username=username).first()
if email:
return cls.query.filter_by(email=email).first()
class CommitteePost(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
officials_email = db.Column(db.String)
committee_id = db.Column(db.Integer, db.ForeignKey('committee.id'))
committee = db.relationship("Committee", back_populates="posts")
is_official = db.Column(db.Boolean)
terms = db.relationship("CommitteePostTerm", back_populates="post")
weight = db.Column(db.Integer, default=1)
def soft_hyphenate(self, name):
words = [
"ansvarig", "skyddsombud", "ordförande", "frågor", "ombud",
"ledare"
]
hyphenated = name
for word in words:
hyphenated = hyphenated.replace(word, "­" + word, 1)
return hyphenated
def current_terms(self):
date = datetime.now()
terms = CommitteePostTerm.query.filter(
CommitteePostTerm.post_id == self.id).filter(
and_(CommitteePostTerm.start_date <= date,
CommitteePostTerm.end_date >= date)).all()
return terms
def new_term(self, start_date, end_date):
term = CommitteePostTerm()
term.post = self
term.start_date = start_date
term.end_date = end_date
return term
def to_dict(self):
terms = []
for term in self.current_terms():
terms.append({
"id": term.id,
"startDate": term.start_date,
"endDate": term.end_date,
"user": term.user.to_dict_without_terms()
})
return {
"id": self.id,
"name": self.name,
"email": self.officials_email,
"committeeId": self.committee_id,
"committeeCategory": self.committee.category.to_dict(),
"isOfficial": self.is_official,
"currentTerms": terms,
"weight": self.weight
}
def to_dict_without_terms(self, hyphenate=False):
return {
"id": self.id,
"name": self.soft_hyphenate(self.name) if hyphenate else self.name,
"email": self.officials_email,
"committeeId": self.committee_id,
"committeeCategory": self.committee.category.to_dict(),
"isOfficial": self.is_official,
"weight": self.weight
}
def to_dict_with_all_terms(self):
terms = []
current_terms = self.current_terms()
for term in self.terms:
terms.append({
"id": term.id,
"startDate": term.start_date,
"endDate": term.end_date,
"user": term.user.to_dict_without_terms(),
"current": term in current_terms
})
return {
"id": self.id,
"name": self.name,
"email": self.officials_email,
"committeeId": self.committee_id,
"committeeCategory": self.committee.category.to_dict(),
"isOfficial": self.is_official,
"terms": terms,
"weight": self.weight
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
kth_id = db.Column(db.String, unique=True)
email = db.Column(db.String)
profile_picture = db.Column(db.String,
default="/static/profiles/default.png")
first_name = db.Column(db.String)
last_name = db.Column(db.String)
frack_name = db.Column(db.String, nullable=True)
kth_year = db.Column(db.Integer)
linkedin = db.Column(db.String, nullable=True)
facebook = db.Column(db.String, nullable=True)
alumni = db.Column(db.Boolean, default=False)
post_terms = db.relationship("CommitteePostTerm",
back_populates="user",
lazy='dynamic')
is_admin = db.Column(db.Boolean, default=False)
def to_dict(self):
terms = []
for term in self.post_terms:
terms.append({
"post": term.post.to_dict_without_terms(),
"startDate": term.start_date,
"endDate": term.end_date
})
return {
"id":
self.id,
"email":
self.email,
"kthId":
self.kth_id,
"profilePicture":
self.profile_picture
if not RECEPTION_MODE else "/static/profiles/default.png",
"firstName":
self.frack_name if (RECEPTION_MODE and self.frack_name is not None)
else self.first_name,
"lastName":
"" if (RECEPTION_MODE
and self.frack_name is not None) else self.last_name,
"frackName":
self.frack_name,
"kthYear":
self.kth_year,
"linkedin":
self.linkedin if not RECEPTION_MODE else None,
"facebook":
self.facebook if not RECEPTION_MODE else None,
"committeePostTerms":
terms,
"alumni":
self.alumni,
"isAdmin":
self.is_admin
}
def to_dict_without_terms(self):
return {
"id":
self.id,
"email":
self.email,
"kthId":
self.kth_id,
"profilePicture":
self.profile_picture
if not RECEPTION_MODE else "/static/profiles/default.png",
"firstName":
self.frack_name if (RECEPTION_MODE and self.frack_name is not None)
else self.first_name,
"lastName":
"" if (RECEPTION_MODE
and self.frack_name is not None) else self.last_name,
"frackName":
self.frack_name,
"kthYear":
self.kth_year,
"linkedin":
self.linkedin if not RECEPTION_MODE else None,
"facebook":
self.facebook if not RECEPTION_MODE else None,
"alumni":
self.alumni,
"isAdmin":
self.is_admin
}
