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 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 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 DocumentTags(db.Model):
id = db.Column(db.Integer, primary_key=True)
itemId = db.Column(db.Integer, db.ForeignKey("documents.itemId"))
tagId = db.Column(db.Integer, db.ForeignKey("tags.tagId"))
def serialize(self):
tag = Tag.query.get(self.tagId)
return tag.to_dict()
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 Badges(db.Model):
__tablename__ = 'Badges'
id = db.Column(db.String(100), primary_key=True)
image = db.Column(db.String(100), nullable=False)
csv = db.Column(db.String(100), nullable=False)
text_color = db.Column(db.String(100), nullable=False)
badge_size = db.Column(db.String(100), nullable=False)
download_link = db.Column(db.String)
image_link = db.Column(db.String)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
deleted_at = db.Column(db.DateTime, nullable=True)
badge_name = db.Column(db.String(100), default='My Badge')
user_id = db.Column(db.String(100),
db.ForeignKey('User.id', ondelete='CASCADE'))
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
def delete_from_db(self):
self.deleted_at = datetime.utcnow()
self.save_to_db()
@classmethod
def getBadge(cls, badge_id):
return cls.query.filter_by(id=badge_id).first()
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 Permissions(db.Model):
__tablename__ = 'Permissions'
id = db.Column(db.String(100), primary_key=True)
isUser = db.Column(db.Boolean, default=False)
isAdmin = db.Column(db.Boolean, default=False)
isSales = db.Column(db.Boolean, default=False)
user_id = db.Column(db.String(100),
db.ForeignKey('User.id', ondelete='CASCADE'))
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
@classmethod
def getPermissions(cls, permissions_id):
return cls.query.filter_by(id=permissions_id).first()
@classmethod
def get_by_uid(cls, uid=None):
return cls.query.filter_by(user_id=uid).first()
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 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 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 File(db.Model):
__tablename__ = 'File'
id = db.Column(db.String(100))
filename = db.Column(db.String(100), nullable=False, primary_key=True)
filetype = db.Column(db.String(100), nullable=False)
user_id = db.Column(db.String(100),
db.ForeignKey('User.id', ondelete='CASCADE'))
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
from api.db import db
from flask_security import UserMixin, RoleMixin
roles_users = db.Table(
"roles_users",
db.Column("user_id", db.Integer(), db.ForeignKey("user.id")),
db.Column("role_id", db.Integer(), db.ForeignKey("role.id")),
)
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
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 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
}
from api.db import db
import datetime
imageAssociation = db.Table(
'album_images', db.Model.metadata,
db.Column('album_id', db.Integer, db.ForeignKey('albums.albumId')),
db.Column('image_id', db.Integer, db.ForeignKey('images.imageId')))
video_playlist_table = db.Table(
'album_videos', db.Model.metadata,
db.Column('album_id',
db.Integer,
db.ForeignKey('albums.albumId'),
primary_key=True),
db.Column('video_id',
db.Integer,
db.ForeignKey('video.id'),
primary_key=True))
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)
from api.db import db
import datetime
from api.models.post_tag import PostTag
#Association table for tags and events
events_tags = db.Table(
'event_Tags', db.Model.metadata,
db.Column('event_id', db.Integer, db.ForeignKey('event.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('post_tag.id')))
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)
from api.db import db, CRUDMixin
from api import bcrypt
api_category_article = db.Table('api_category_article',
db.Column('category_id', db.Integer, db.ForeignKey('api_category.id'), primary_key=True),
db.Column('article_id', db.Integer, db.ForeignKey('api_article.id'), primary_key=True),
db.PrimaryKeyConstraint('category_id', 'article_id')
)
class CategoryModel(db.Model, CRUDMixin):
__tablename__ = "api_category"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
def __repr__(self):
return '<id {}>'.format(self.id)
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))