class OrderDetails(db.Model, BaseModel):
# table name
__tablename__ = 'order_details'
# displayed fields
visible = ['id', 'ticket_id', 'order_id', 'count', 'price', 'created_at', 'updated_at']
# columns definitions
id = db.Column(db.Integer, primary_key=True)
ticket_id = db.Column(
db.String(40),
db.ForeignKey('tickets.id'),
nullable=False
)
ticket = db.relationship('Ticket')
order_id = db.Column(
db.String(180),
db.ForeignKey('orders.id'),
nullable=False
)
order = db.relationship('Order')
count = db.Column(db.Integer)
price = db.Column(db.Integer)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.created_at = datetime.datetime.now()
self.updated_at = datetime.datetime.now()
class Order(db.Model, BaseModel):
# table name
__tablename__ = 'orders'
# displayed fields
visible = [
'id', 'user_id', 'referal_id', 'status', 'banned', 'created_at',
'updated_at'
]
# columns definitions
id = db.Column(db.String, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User')
referal_id = db.Column(db.Integer,
db.ForeignKey('referals.id'),
nullable=False)
banned = db.Column(db.Boolean())
referal = db.relationship('Referal')
status = db.Column(db.String)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.id = 'ds-' + datetime.datetime.now().strftime("%Y%m%d.%H%M%S%f")
self.created_at = datetime.datetime.now()
self.updated_at = datetime.datetime.now()
class Thirdparty(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(120), nullable=False)
last_name = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
phone = db.Column(db.String(30))
reservations = db.relationship('Reservation',
backref='thirdparty',
lazy=True)
lendings = db.relationship('Lending', backref='thirdparty', lazy=True)
def to_dict(self):
obj = {
"id": self.id,
"first_name": self.first_name,
"last_name": self.last_name,
"email": self.email,
"phone": self.phone
}
return obj
def from_dict(self, data):
for field in ['first_name', 'last_name', 'email', 'phone']:
if field in data:
setattr(self, field, data[field])
@staticmethod
def check_data(data: dict, new: bool = False):
error = utils.check_data(data, definition, new) \
or utils.check_name(data, 'first_name') \
or utils.check_name(data, 'last_name') \
or utils.check_email(data, 'email') \
or utils.check_phone(data, 'phone')
return error
class Booth(db.Model, BaseModel):
# table name
__tablename__ = 'booths'
# displayed fields
visible = [
'id', 'user_id', 'stage_id', 'points', 'summary', 'type', 'logo_url',
'url', 'name', 'channel_id', 'created_at', 'updated_at'
]
# columns definitions
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(40),
db.ForeignKey('users.id'),
nullable=True)
user = db.relationship('User')
stage_id = db.Column(db.String(40), db.ForeignKey('stages.id'))
stage = db.relationship('Stage')
summary = db.Column(db.Text)
type = db.Column(db.String)
channel_id = db.Column(db.String)
points = db.Column(db.Integer)
name = db.Column(db.String(255))
url = db.Column(db.String(255))
logo_url = db.Column(db.String(255))
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.created_at = datetime.datetime.now()
self.updated_at = datetime.datetime.now()
self.summary = ''
self.points = 0
class Comment(db.Model, BaseModel):
__tablename__ = 'comments'
visible = ['id', 'feed_id', 'user_id', 'content', 'created_at', 'updated_at']
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
user_id = db.Column(
db.Integer,
db.ForeignKey('users.id'),
nullable=False
)
user = db.relationship('User')
feed_id = db.Column(
db.Integer,
db.ForeignKey('feeds.id'),
nullable=False
)
feed = db.relationship('Feed')
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.created_at = datetime.now() + timedelta(hours=7)
self.updated_at = datetime.now() + timedelta(hours=7)
class FaqType(db.Model):
"""Page model class"""
__tablename__ = 'faq_types'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
event_id = db.Column(db.Integer,
db.ForeignKey('events.id', ondelete='CASCADE'))
event = db.relationship("Event",
backref="faq_types",
foreign_keys=[event_id])
faqs = db.relationship('Faq', backref="faq_type")
def __init__(self, name=None, event_id=None):
self.name = name
self.event_id = event_id
def __repr__(self):
return '<FAQType %r>' % self.name
def __str__(self):
return unicode(self).encode('utf-8')
def __unicode__(self):
return self.name
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'id': self.id,
'name': self.name,
}
class SessionType(db.Model):
__tablename__ = "session_types"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
length = db.Column(db.String, nullable=False)
event_id = db.Column(db.Integer,
db.ForeignKey('events.id', ondelete='CASCADE'))
event = db.relationship("Event",
backref="session_type",
foreign_keys=[event_id])
sessions = db.relationship('Session', backref="session_type")
def __init__(self, name=None, length=None, event_id=None):
self.name = name
self.length = length
self.event_id = event_id
def __repr__(self):
return '<SessionType %r>' % self.name
def __str__(self):
return unicode(self).encode('utf-8')
def __unicode__(self):
return self.name
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {'id': self.id, 'name': self.name, 'length': self.length}
class UsersEventsRoles(db.Model):
__tablename__ = 'users_events_roles'
__table_args__ = (
db.UniqueConstraint(
'user_id', 'event_id', 'role_id', name='uq_uer_user_event_role'
),
)
id = db.Column(db.Integer, primary_key=True)
event_id = db.Column(
db.Integer, db.ForeignKey('events.id', ondelete='CASCADE'), nullable=False
)
user_id = db.Column(
db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'), nullable=False
)
user = db.relationship("User")
role_id = db.Column(
db.Integer, db.ForeignKey('roles.id', ondelete='CASCADE'), nullable=False
)
role = db.relationship("Role")
def __repr__(self):
return f'<UER {self.user!r}:{self.event_id!r}:{self.role!r}>'
class AccessToken(db.Model, BaseModel):
# table name
__tablename__ = 'access_tokens'
# visible fields
visible = [
'id', 'user_id', 'access_token', 'refresh_token', 'client_id',
'created_at', 'updated_at'
]
# columns definitions
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(40),
db.ForeignKey('users.id'),
nullable=False)
user = db.relationship('User')
client_id = db.Column(db.String(40),
db.ForeignKey('clients.id'),
nullable=False)
client = db.relationship('Client')
access_token = db.Column(db.String)
refresh_token = db.Column(db.String)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.created_at = datetime.datetime.now()
self.updated_at = datetime.datetime.now()
def init_token(self, access_token, refresh_token, user_id):
self.access_token = access_token
self.refresh_token = refresh_token
self.user_id = user_id
return self
class News(db.Model):
__tablename__ = 'gk-news'
id = db.Column('news_id', db.Integer, primary_key=True, key='id')
title = db.Column('tytul', db.String(50), key='title', nullable=False)
content = db.Column('tresc', db.Text, key='content', nullable=False)
username = db.Column('who', db.String(20), key='username', nullable=True)
author_id = db.Column('userid',
db.Integer,
db.ForeignKey('gk-users.id'),
key='author_id')
comments_count = db.Column('komentarze',
db.Integer,
key='comments_count',
default=0)
last_comment_date_time = db.Column('ostatni_komentarz',
db.DateTime,
key='last_comment_date_time',
nullable=False,
default="0000-00-00 00:00:00")
created_on_date_time = db.Column('date',
db.DateTime,
key='created_on_date_time',
default=datetime.datetime.utcnow)
czas_postu = db.Column(db.DateTime, default="0000-00-00 00:00:00")
# author = db.relationship('User', backref=db.backref('news'))
news_comments = db.relationship('NewsComment',
backref="news",
cascade="all,delete")
news_subscriptions = db.relationship('NewsSubscription',
backref="news",
cascade="all,delete")
class BookedTicket(db.Model):
__tablename__ = 'booked_ticket'
__table_args__ = (db.UniqueConstraint('user_id',
'ticket_id',
name='user_ticket_uc'), )
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id',
ondelete='CASCADE'))
user = db.relationship('User', backref='booked_tickets')
ticket_id = db.Column(db.Integer,
db.ForeignKey('ticket.id', ondelete='CASCADE'))
ticket = db.relationship('Ticket', backref='booked_tickets')
quantity = db.Column(db.Integer)
def __init__(self, user, ticket, quantity):
self.user = user
self.ticket = ticket
self.quantity = quantity
def __repr__(self):
return '<BookedTicket %r by %r' % (
self.ticket,
self.user,
)
def __str__(self):
return unicode(self).encode('utf-8')
def __unicode__(self):
return self.ticket
class Lesson(db.Model):
"""Lesson
A lesson takes place every week. This is only a repetition pattern.
Each week a new event (see `Event`) is created.
"""
__tablename__ = 'lesson'
id = db.Column(db.Integer, primary_key=True, unique=True, nullable=False)
school_id = db.Column(db.Integer,
db.ForeignKey('school.id'),
nullable=False)
tutor_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
available = db.Column(db.Boolean, nullable=False, default=True)
# Time and repetition pattern (weekly)
weekday = db.Column(db.Enum(Weekday),
nullable=False,
default=Weekday.monday)
time_id = db.Column(db.Integer, db.ForeignKey('time.id'), nullable=False)
tutor = db.relationship('User',
foreign_keys=[tutor_id],
back_populates='tutor_lessons')
students = db.relationship('User',
secondary='user_lesson',
back_populates='student_lessons')
time = db.relationship('Time', foreign_keys=[time_id])
events = db.relationship('Event', back_populates='lesson')
def __repr__(self):
return f'<Lesson {self.tutor.name}@{self.weekday}>'
class Invite(db.Model):
"""invite model class"""
__tablename__ = 'invites'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
user = db.relationship("User", backref="invite")
event_id = db.Column(db.Integer,
db.ForeignKey('events.id', ondelete='CASCADE'))
session_id = db.Column(db.Integer,
db.ForeignKey('sessions.id', ondelete='CASCADE'))
session = db.relationship("Session", backref="invite")
hash = db.Column(db.String, nullable=False)
def __init__(self, event_id=None, user_id=None, session_id=None):
self.user_id = user_id
self.event_id = event_id
self.session_id = session_id
def __repr__(self):
return '<Invite %r>' % self.user_id
def __str__(self):
return self.__repr__()
@property
def serialize(self):
"""Return object data in easily serializable format"""
return {
'id': self.id,
'user_id': self.user_id,
'session_id': self.session_id
}
class UserFavouriteSession(db.Model, Timestamp):
__tablename__ = 'user_favourite_sessions'
__table_args__ = (db.UniqueConstraint('session_id',
'user_id',
name='uq_session_user'), )
id = db.Column(db.Integer, primary_key=True)
session_id = db.Column(db.Integer,
db.ForeignKey('sessions.id', ondelete='CASCADE'))
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'))
session = db.relationship('Session', backref='favourites')
user = db.relationship('User', backref='favourite_sessions')
@property
def safe_user(self):
from app.api.helpers.permission_manager import require_current_user
from app.models.user import User
if not self.user_id:
return None
can_access = require_current_user() and (
current_user.is_staff or current_user.id == self.user_id)
if not self.user.is_profile_public and not can_access:
name = self.user.anonymous_name
return User(
id=self.user.id,
email='*****@*****.**',
public_name=name,
)
return self.user
class UserTicket(db.Model, BaseModel):
# table name
__tablename__ = 'user_tickets'
# displayed fields
visible = ['id', 'user_id', 'ticket_id', 'ticket_code']
# columns definitions
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(
db.Integer,
db.ForeignKey('users.id'),
nullable=False
)
user = db.relationship('User')
ticket_id = db.Column(
db.Integer,
db.ForeignKey('tickets.id'),
nullable=False)
ticket = db.relationship('Ticket')
ticket_code = db.Column(db.String)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.created_at = datetime.datetime.now()
self.updated_at = datetime.datetime.now()
codes = [r.ticket_code for r in db.session.query(UserTicket.ticket_code).all()]
code = secrets.token_hex(8)
while (code in codes):
code = secrets.token_hex(8)
self.ticket_code = code
class Dog(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
details = db.Column(db.String(300), nullable=True)
owner_id = db.Column(db.Integer,
db.ForeignKey('owner.id', ondelete="CASCADE"))
breed_id = db.Column(db.Integer, db.ForeignKey('breed.id'))
gender = db.Column(db.Boolean, nullable=False)
breed = db.relationship("Breed", backref="dog", cascade="all, delete")
photos = db.relationship("Photo",
backref="dog",
cascade="all, delete",
passive_deletes=True)
interest = db.relationship("Interest",
backref="dog",
cascade="all, delete")
conversations = db.relationship('Conversation',
secondary=dog_conversation,
back_populates='dogs',
cascade="all, delete")
messages = db.relationship('Message',
back_populates='dogs',
cascade="all, delete",
passive_deletes=True)
def __repr__(self):
return f"<Dog {self.name} />"
class Notification(db.Model, BaseModel):
__tablename__ = 'notifications'
visible = ['id', 'message', 'sender_uid', 'receiver_uid', 'type', 'attachment', 'created_at', 'updated_at']
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.Text)
attachment = db.Column(db.String)
sender_uid = db.Column(
db.Integer,
db.ForeignKey('users.id'),
nullable=False
)
sender = db.relationship("User", foreign_keys=[sender_uid])
receiver_uid = db.Column(
db.Integer,
db.ForeignKey('users.id'),
nullable=False
)
receiver = db.relationship('User', foreign_keys=[receiver_uid])
type = db.Column(db.String)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.created_at = datetime.now() + timedelta(hours=7)
self.updated_at = datetime.now() + timedelta(hours=7)
class Permission(db.Model):
"""Role-Service Permissions"""
__tablename__ = 'permissions'
__table_args__ = (db.UniqueConstraint('role_id',
'service_id',
name='role_service_uc'), )
id = db.Column(db.Integer, primary_key=True)
role_id = db.Column(db.Integer,
db.ForeignKey('roles.id', ondelete='CASCADE'))
role = db.relationship('Role')
service_id = db.Column(db.Integer,
db.ForeignKey('services.id', ondelete='CASCADE'))
service = db.relationship('Service')
can_create = db.Column(db.Boolean, nullable=False, default=True)
can_read = db.Column(db.Boolean, nullable=False, default=True)
can_update = db.Column(db.Boolean, nullable=False, default=True)
can_delete = db.Column(db.Boolean, nullable=False, default=True)
def __repr__(self):
return f'<Perm {self.role!r} for {self.service!r}>'
class AccessCode(SoftDeletionModel):
__tablename__ = "access_codes"
id: int = db.Column(db.Integer, primary_key=True)
code: str = db.Column(db.String)
access_url: str = db.Column(db.String)
is_active: bool = db.Column(db.Boolean)
tickets_number: int = db.Column(
db.Integer
) # For event level access this holds the max. uses
min_quantity: int = db.Column(db.Integer)
max_quantity: int = db.Column(
db.Integer
) # For event level access this holds the months for which it is valid
valid_from: datetime = db.Column(db.DateTime(timezone=True), nullable=True)
valid_till: datetime = db.Column(db.DateTime(timezone=True), nullable=True)
ticket_id: int = db.Column(
db.Integer, db.ForeignKey('tickets.id', ondelete='CASCADE')
)
event_id: int = db.Column(db.Integer, db.ForeignKey('events.id', ondelete='CASCADE'))
created_at: datetime = db.Column(db.DateTime(timezone=True), default=func.now())
marketer_id: int = db.Column(
db.Integer, db.ForeignKey('users.id', ondelete='CASCADE')
)
marketer = db.relationship('User', backref='access_codes_')
ticket = db.relationship('Ticket', backref='access_code', foreign_keys=[ticket_id])
event = db.relationship('Event', backref='access_codes', foreign_keys=[event_id])
@staticmethod
def get_service_name():
return 'access_code'
class TicketTransferLog(db.Model, BaseModel):
# table name
__tablename__ = 'ticket_transfer_logs'
# displayed fields
visible = [
'user_ticket_id', 'sender_user_id', 'receiver_user_id', 'sender',
'receiver', 'created_at', 'updated_at'
]
# columns definitions
id = db.Column(db.Integer, primary_key=True)
user_ticket_id = db.Column(db.Integer)
sender_user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
receiver_user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
sender = db.relationship("User", foreign_keys=[sender_user_id])
receiver = db.relationship("User", foreign_keys=[receiver_user_id])
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.created_at = datetime.datetime.now()
self.updated_at = datetime.datetime.now()
class RoleInvite(db.Model):
__tablename__ = 'role_invites'
__table_args__ = (UniqueConstraint(
'email',
'role_id',
'event_id',
name='email_role_event_uc',
), )
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String, nullable=False)
role_name = db.Column(db.String, nullable=False)
event_id = db.Column(db.Integer,
db.ForeignKey('events.id', ondelete='CASCADE'))
event = db.relationship('Event', back_populates='role_invites')
role_id = db.Column(db.Integer,
db.ForeignKey('roles.id', ondelete='CASCADE'))
role = db.relationship("Role")
hash = db.Column(db.String, default=generate_hash)
created_at = db.Column(db.DateTime(timezone=True), default=func.now())
status = db.Column(db.String, default="pending")
def has_expired(self):
# Check if invitation link has expired (it expires after 24 hours)
return datetime.now(pytz.utc) > self.created_at + timedelta(hours=24)
def __repr__(self):
return '<RoleInvite {!r}:{!r}:{!r}>'.format(self.email, self.event_id,
self.role_id)
class Need(db.Model):
__tablename__ = 'needs'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String)
description = db.Column(db.String)
estimated_tokens = db.Column(db.Integer)
status = db.Column(db.String)
speaker_conclusion = db.Column(db.String)
team_conclusion = db.Column(db.String)
used_tokens = db.Column(db.Integer)
# creation_date = db.Column(db.DateTime)
# validation_date = db.Column(db.DateTime)
# close_date = db.Column(db.DateTime)
id_assigned_team = db.Column(db.Integer, db.ForeignKey(Team.id, name="fk_assigned_team_id"))
team = db.relationship('Team', lazy='joined')
id_assigned_speaker = db.Column(db.Integer, db.ForeignKey(Speaker.id, name="fk_assigned_speaker_id"))
speaker = db.relationship('Speaker', lazy='joined')
def __repr__(self):
return "<Need (id='{}, title='{}', description='{}', estimated_tokens='{}', status='{}, " \
"speaker_conclusion='{}', team_conclusion='{}', close_date='{}', id_team='{}', id_speaker='{}')>".format(
self.id, self.title, self.description, self.estimated_tokens, self.status, self.speaker_conclusion,
self.team_conclusion, self.used_tokens, self.id_assigned_team, self.id_assigned_speaker)
class SpeakerInvite(db.Model, Timestamp):
__tablename__ = 'speaker_invites'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String, nullable=False)
status = db.Column(db.String, default="pending")
session_id = db.Column(
db.Integer, db.ForeignKey('sessions.id', ondelete='CASCADE'), nullable=False
)
session = db.relationship('Session', backref='speaker_invites')
event_id = db.Column(
db.Integer, db.ForeignKey('events.id', ondelete='CASCADE'), nullable=False
)
event = db.relationship('Event', backref='speaker_invites')
def send_invite(self, inviter_email):
"""
Send mail to invitee
"""
session = Session.query.filter_by(id=self.session_id).first()
frontend_url = get_settings()['frontend_url']
cfs_link = f"{frontend_url}/e/{self.event.identifier}/cfs"
if not has_access('is_speaker_for_session', id=session.id):
raise ForbiddenError({'source': ''}, "Speaker Access Required")
inviter = Speaker.query.filter_by(
email=inviter_email, event_id=session.event_id, deleted_at=None
).first()
send_email_speaker_invite(self.email, session, cfs_link, inviter)
def __repr__(self):
return f'<SpeakerInvite {self.email!r}:{self.session_id!r}>'
class User(db.Model, UserMixin):
"""
Basic user model
"""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(255))
email = db.Column(db.Unicode(255), unique=True)
password = db.Column(db.Unicode(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'))
skills = db.relationship("Skill",
secondary=user_skills,
backref=db.backref("users", lazy='dynamic'))
def __repr__(self):
return "{}: {}".format(self.name, self.email)
@property
def _user_skills_as_set(self):
"""
returns student skills as set to work with it
"""
return set([skill.id for skill in self.skills])
class EventTopic(db.Model):
"""Event topic object table"""
__tablename__ = 'event_topics'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String, nullable=False)
slug = db.Column(db.String, unique=True, nullable=False)
events = db.relationship('Event', backref='event_topics')
event_sub_topics = db.relationship('EventSubTopic', backref='event-topic')
def __init__(self,
name=None,
slug=None):
self.name = name
self.slug = get_new_slug(name=self.name)
def __repr__(self):
return '<EventTopic %r>' % self.name
def __str__(self):
return unicode(self).encode('utf-8')
def __unicode__(self):
return self.name
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {'id': self.id, 'name': self.name, 'slug': self.slug}
class Schedule(db.Model, BaseModel):
# table name
__tablename__ = 'schedules'
# displayed fields
visible = ['id', 'event_id', 'stage_id', 'time_start', 'time_end', 'created_at', 'updated_at']
# columns definitions
id = db.Column(db.Integer, primary_key=True)
event_id = db.Column(
db.String(40),
db.ForeignKey('events.id'),
nullable=False
)
event = db.relationship('Event')
stage_id = db.Column(
db.String(40),
db.ForeignKey('stages.id'),
nullable=False
)
stage = db.relationship('Stage')
time_start = db.Column(db.DateTime)
time_end = db.Column(db.DateTime)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.created_at = datetime.datetime.now()
self.updated_at = datetime.datetime.now()
class Report(db.Model):
"""Report
Reports are a list of events that took place in a specific time
period.
Fields:
- `id`: Primary key
- `period_id`: Associated period
- `user_id`: Creator of this report
- `comment`: Additional information by the user
"""
__tablename__ = 'report'
id = db.Column(db.Integer, primary_key=True, unique=True, nullable=False)
school_id = db.Column(db.Integer,
db.ForeignKey('school.id'),
nullable=False)
period_id = db.Column(db.Integer,
db.ForeignKey('period.id'),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
comment = db.Column(db.String(240))
# Relationships
period = db.relationship('Period', back_populates='reports')
user = db.relationship('User', back_populates='reports')
events = db.relationship('Event',
secondary='report_event',
back_populates='report')
def __repr__(self):
return f'<Report {self.user.name}@{self.period_id}>'
class PointTransactionLog(db.Model, BaseModel):
# table name
__tablename__ = 'point_transaction_log'
# displayed fields
visible = [
'id', 'booth_id', 'user_id', 'amount', 'created_at', 'updated_at'
]
# columns definitions
id = db.Column(db.Integer, primary_key=True)
booth_id = db.Column(db.String(40),
db.ForeignKey('booths.id'),
nullable=False)
booth = db.relationship('Booth')
user_id = db.Column(db.String(40),
db.ForeignKey('users.id'),
nullable=False)
user = db.relationship('User')
amount = db.Column(db.Integer)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
def __init__(self):
self.created_at = datetime.datetime.now()
self.updated_at = datetime.datetime.now()
class Notification(db.Model, Timestamp):
"""
Model for storing user notifications.
"""
__tablename__ = 'notifications'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'),
nullable=False)
user = db.relationship('User',
backref='notifications',
foreign_keys=[user_id])
is_read = db.Column(db.Boolean,
nullable=False,
default=False,
server_default='False')
content_id = db.Column(
db.Integer,
db.ForeignKey('notification_content.id', ondelete='CASCADE'),
nullable=False,
)
content = db.relationship('NotificationContent',
backref='content',
foreign_keys=[content_id])
class EmailNotification(SoftDeletionModel):
"""email notifications model class"""
__tablename__ = 'email_notifications'
id = db.Column(db.Integer, primary_key=True)
next_event = db.Column(db.Boolean, default=False)
new_paper = db.Column(db.Boolean, default=False)
session_accept_reject = db.Column(db.Boolean, default=False)
session_schedule = db.Column(db.Boolean, default=False)
after_ticket_purchase = db.Column(db.Boolean, default=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'))
event_id = db.Column(db.Integer, db.ForeignKey('events.id', ondelete='CASCADE'))
event = db.relationship("Event")
user = db.relationship("User", backref="email_notifications")
def __init__(self,
next_event=False,
new_paper=False,
session_accept_reject=False,
session_schedule=False,
after_ticket_purchase=True,
user_id=None,
event_id=None,
deleted_at=None):
self.next_event = next_event
self.new_paper = new_paper
self.session_accept_reject = session_accept_reject
self.session_schedule = session_schedule
self.user_id = user_id
self.event_id = event_id
self.after_ticket_purchase = after_ticket_purchase
self.deleted_at = deleted_at
def __str__(self):
return 'User:'******' Event: ' + self.event_id
