class Module(db.Model):
__tablename__ = 'Modules'
id = db.Column(db.Integer, primary_key=True)
ticketInclude = db.Column(db.Boolean, default=False)
paymentInclude = db.Column(db.Boolean, default=False)
donationInclude = db.Column(db.Boolean, default=False)
def __init__(self,
ticketInclude=True,
paymentInclude=True,
donationInclude=True):
self.id = 1
self.donationInclude = donationInclude
self.paymentInclude = paymentInclude
self.ticketInclude = ticketInclude
@classmethod
def set_default(cls):
if len(Module.query.filter_by(id=1).all()) == 0:
db.session.add(Module())
db.session.commit()
else:
print('Module already created')
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)
class Admin(db.Model):
__tablename__ = 'Admin'
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())
def __init__(self, id_, username, password, email, photoURL=None):
self.id = id_
self.username = username
if password:
self.password = generate_password_hash(password)
self.email = email
if photoURL:
self.photoURL = photoURL
else:
self.photoURL = 'Some default asset'
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)
@classmethod
def getAdmin(cls, admin_id=None, username=None):
if username is None:
return cls.query.filter_by(id=admin_id).first()
if admin_id is None:
return cls.query.filter_by(username=username).first()
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 Pigment(Model, db.Model):
__tablename__ = 'pigments'
id = db.Column(db.Integer,
db.Sequence('pigments_id_seq'),
primary_key=True)
spectrum = db.Column(db.ARRAY(db.Float))
name = db.Column(db.String)
def color(self):
return Color(self.spectrum, 1, self.name)
def short_dict(self):
return {
'id': self.id,
'rgb': self.color().to_rgb(),
'hex': self.color().to_hex(),
'name': self.name,
'url': route_for('pigment', pigment_id=self.id)
}
def full_dict(self):
return {
'id': self.id,
'rgb': self.color().to_rgb(),
'hex': self.color().to_hex(),
'name': self.name,
'spectrum': self.spectrum,
'url': route_for('pigment', pigment_id=self.id)
}
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 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 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 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 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 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 User(db.Model):
__tablename__ = 'user'
id = db.Column(Integer, primary_key=True)
username = db.Column(String(64), unique=False, nullable=False)
password = db.Column(String(255), unique=False, nullable=False)
def __init__(self, username=None, password=None):
self.username = username
self.password = password
def __repr__(self):
return 'User(id = {0}, username = {1})'.format(self.id, self.username)
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Utilities(db.Model):
__tablename__ = 'Utilities'
id = db.Column(db.String(100), primary_key=True)
pricing = db.Column(db.Float)
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)
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 Settings(db.Model):
__tablename__ = 'Settings'
environment = ['Development', 'Production', 'Staging']
id = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
primary_key=True)
appEnvironment = db.Column(db.Integer, nullable=False)
appName = db.Column(db.String, default='Badgeyay', nullable=False)
secretKey = db.Column(db.String, nullable=False)
# Firebase config
firebaseStorageBucket = db.Column(db.String, nullable=False)
firebaseDatabaseURL = db.Column(db.String, nullable=False)
# Email settings
fromMail = db.Column(db.String, default="*****@*****.**")
# Send Grid config
sendGridApiKey = db.Column(db.String)
def __init__(self, appEnvironment, appName, secretKey, firebaseDatabaseURL,
firebaseStorageBucket, **kwargs):
self.appEnvironment = appEnvironment
self.appName = appName
self.secretKey = secretKey
self.firebaseStorageBucket = firebaseStorageBucket
self.firebaseDatabaseURL = firebaseDatabaseURL
if 'fromMail' in kwargs.keys():
self.fromMail = kwargs['fromMail']
if 'sendGridApiKey' in kwargs.keys():
self.sendGridApiKey = kwargs['sendGridApiKey']
def save_to_db(self):
try:
db.session.add(self)
db.session.commit()
except Exception as e:
print(e)
db.session.rollback()
db.session.flush()
@staticmethod
def init_setup():
if len(Settings.query.all()) == 0:
settings = Settings(0, 'Badgeyay', config.POSTGRES['secret'],
'https://badgeyay-195bf.firebaseio.com',
'badgeyay-195bf.appspot.com')
settings.save_to_db()
else:
settings = Settings.latest_settings()
return settings
@staticmethod
def latest_settings():
return Settings.query.order_by(Settings.id.desc()).first()
class Tag(db.Model):
__tablename__ = "tags"
tagId = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
title_en = db.Column(db.String)
def to_dict(self):
return {
"id": self.tagId,
"title": {
"se": self.title,
"en": self.title_en
}
}
def __repr__(self):
return "Tag with title %s and id %s" % (self.title, self.tagId)
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 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 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)
class UserModel(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
@classmethod
def find_all(cls):
return cls.query.all()
@classmethod
def find_by_id(cls, user_id):
return cls.query.get(user_id)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def json(self):
return {"id": self.id, "name": self.name}
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 ResetPasswordToken(db.Model):
__tablename__ = 'Reset Password Token'
id = db.Column(db.String, primary_key=True)
token = db.Column(db.String, nullable=False)
def __init__(self, uid, token):
self.id = uid
self.token = token
def save_to_db(self):
try:
db.session.add(self)
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
class SocialContent(db.Model):
__tablename__ = 'SocialContent'
name = db.Column(db.String, primary_key=True)
description = db.Column(db.String, nullable=False)
link = db.Column(db.String, nullable=False)
icon = db.Column(db.String,
nullable=False) # Semantic ui class for the icon of media
def __init__(self, name, description, link, icon):
self.name = name.lower()
self.description = description
self.link = link
self.icon = icon
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)
@classmethod
def populate_initial(cls):
if not SocialContent.check_key('github'):
db.session.add(
SocialContent('github', 'Social network for developers',
'https://github.com/fossasia/badgeyay',
'github icon'))
db.session.commit()
if not SocialContent.check_key('twitter'):
db.session.add(
SocialContent('twitter',
'Online news and social networking service',
'https://twitter.com/badgeyay', 'twitter icon'))
db.session.commit()
@staticmethod
def check_key(key):
return SocialContent.query.filter_by(name=key.lower()).first()
class Blacklist(db.Model):
"""Class for blacklisted tokens"""
__tablename__ = 'blacklists'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.String(500), unique=True, nullable=False)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
def __init__(self, token):
self.token = token
# Represent the object when it is queried
def __repr__(self):
return '<Token: {}>'.format(self.token)
def token_as_dict(self):
"""Represent the token as a dict"""
return {t.name: getattr(self, t.name) for t in self.__table__.columns}
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 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 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 User(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)
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())
def __init__(self, first_name, last_name, username):
self.first_name = first_name
self.last_name = last_name
self.username = username
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 Note(db.Model):
__tablename__ = 'note'
id = db.Column(Integer, primary_key=True)
author_id = db.Column(Integer, unique=False, nullable=False)
root_note_id = db.Column(Integer, unique=False, nullable=True)
created = db.Column(DateTime,
unique=False,
nullable=False,
server_default=current_timestamp())
updated = db.Column(DateTime,
unique=False,
nullable=False,
server_default=current_timestamp())
kind = db.Column(Integer, unique=False, nullable=False)
sentence = db.Column(Text, unique=False, nullable=False)
def __init__(self,
author_id=None,
root_note_id=None,
created=None,
updated=None,
kind=None,
sentence=None):
self.author_id = author_id
self.root_note_id = root_note_id
self.created = created
self.updated = updated
self.kind = kind
self.sentence = sentence
def __repr__(self):
return ('Note(id = {0}, author_id = {1}, root_note_id = {2}, '\
'created = {3}, updated = {4}, kind = {5}, sentence ={6})'
.format(
self.id,
self.author_id,
self.root_note_id,
self.created,
self.updated,
self.kind,
self.sentence
))
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Stripe(db.Model):
__tablename__ = 'Stripe'
id = db.Column(db.Integer, primary_key=True)
stripe_secret_key = db.Column(db.String)
stripe_refresh_token = db.Column(db.String)
stripe_publishable_key = db.Column(db.String)
stripe_user_id = db.Column(db.String)
stripe_auth_code = db.Column(db.String)
amount = db.Column(db.String)
currency = db.Column(db.String)
def __init__(self,
stripe_secret_key=None,
stripe_refresh_token=None,
stripe_publishable_key=None,
stripe_user_id=None,
stripe_auth_code=None,
amount=None,
currency=None):
self.stripe_secret_key = stripe_secret_key
self.stripe_refresh_token = stripe_refresh_token
self.stripe_publishable_key = stripe_publishable_key
self.stripe_user_id = stripe_user_id
self.stripe_auth_code = stripe_auth_code
self.amount = amount
self.currency = currency
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)
class Image(db.Model):
__tablename__ = "images"
imageId = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String)
photographer = db.Column(
db.String) #TODO: reformat to foreignKey linked to user
date = db.Column(db.DateTime, default=datetime.datetime.now)
needsCred = db.Column(db.Boolean)
editingAllowed = db.Column(db.Boolean)
def to_dict(self):
return {
"id": self.imageId,
"url": self.url,
"photographer": self.photographer,
"date": self.date,
"needsCrediting": self.needsCred,
"editingAllowed": self.editingAllowed
}
