class Review(db.Model):
id = db.Column(db.Integer, primary_key=True)
rating = db.Column(db.Integer, nullable=False, default=0)
title = db.Column(db.String(20), nullable=False)
content = db.Column(db.String(100))
customer_id = db.Column(db.Integer, db.ForeignKey("customer.id"))
product_id = db.Column(db.Integer, db.ForeignKey("product.id"))
class ForumPollAnswer(db.Model, MultiPKMixin):
__tablename__ = 'forums_polls_answers'
poll_id = db.Column(
db.Integer, db.ForeignKey('forums_polls.id'), primary_key=True
)
user_id = db.Column(
db.Integer, db.ForeignKey('users.id'), primary_key=True
)
choice_id = db.Column(
db.Integer, db.ForeignKey('forums_polls_choices.id'), nullable=False
)
@classmethod
def new(
cls, *, poll_id: int, user_id: int, choice_id: bool
) -> 'ForumPollAnswer':
User.is_valid(user_id, error=True)
# ForumPollChoice also validates ForumPoll.
ForumPollChoice.is_valid_choice(choice_id, poll_id=poll_id, error=True)
if cls.from_attrs(poll_id=poll_id, user_id=user_id):
raise APIException('You have already voted for this poll.')
cache.delete(
ForumPollChoice.__cache_key_answers__.format(id=choice_id)
)
return cls._new(poll_id=poll_id, user_id=user_id, choice_id=choice_id)
class Order(db.Model):
id = db.Column(db.Integer, primary_key=True)
sales = db.relationship("Sales", backref="orders", lazy=True)
consumer_id = db.Column(db.Integer, db.ForeignKey("customer.id"))
quantity = db.Column(db.Integer, nullable=False)
vendor_id = db.Column(db.Integer, db.ForeignKey("vendor.id"))
product_id = db.Column(db.Integer, db.ForeignKey("product.id"))
class ForumSubscription(db.Model, MultiPKMixin):
__tablename__ = 'forums_forums_subscriptions'
__cache_key_users__ = 'forums_forums_subscriptions_{forum_id}_users'
__cache_key_of_user__ = 'forums_forums_subscriptions_{user_id}'
user_id = db.Column(
db.Integer, db.ForeignKey('users.id'), primary_key=True
)
forum_id = db.Column(
db.Integer, db.ForeignKey('forums.id'), primary_key=True
)
@classmethod
def new(
cls, *, user_id: int, forum_id: int
) -> Optional['ForumSubscription']:
Forum.is_valid(forum_id, error=True)
User.is_valid(user_id, error=True)
cache.delete(cls.__cache_key_users__.format(forum_id=forum_id))
cache.delete(cls.__cache_key_of_user__.format(user_id=user_id))
return super()._new(user_id=user_id, forum_id=forum_id)
@classmethod
def user_ids_from_forum(cls, id: int) -> List[int]:
return cls.get_col_from_many(
key=cls.__cache_key_users__.format(forum_id=id),
column=cls.user_id,
filter=cls.forum_id == id,
)
class SeriesModel(db.Model):
__tablename__ = 'series'
id = db.Column(db.String(), primary_key=True)
game_id = db.Column(db.String(), db.ForeignKey('games.id'))
drive_id = db.Column(db.String(), db.ForeignKey('drives.id'))
series_index = db.Column(db.Integer(), nullable=False)
team_name = db.Column(db.String(), nullable=False)
series_end_line = db.Column(db.String())
series_result = db.Column(db.String())
series_time_taken_sec = db.Column(db.Integer)
plays = db.relationship('PlayModel')
def __init__(self, id, game_id, drive_id, series_index, team_name, series_end_line=None, series_result=None, series_time_taken_sec=None):
self.id = id
self.game_id = game_id
self.drive_id = drive_id
self.series_index = series_index
self.team_name = team_name
self.series_end_line = series_end_line
self.series_result = series_result
self.series_time_taken_sec = series_time_taken_sec
def get_description(self):
desc = ''
if self.series_result is None:
return 'Series in progress.'
series_yard_description = ''
series_result_formatted = self.series_result.replace('_',' ')
if self.series_end_line < 50:
series_yard_description = series_yard_description + self.team_name + ' ' + str(self.series_end_line)
desc = f'Series complete for {self.team_name}. The series resulted in a {series_result_formatted}, and ended on the {series_yard_description} yard line. '
elif self.series_end_line >= 100:
desc = f'Series complete for {self.team_name}. The series resulted in a touchdown.'
elif self.series_end_line > 50:
series_yard_description = series_yard_description + 'opposition ' + str(100 - self.series_end_line)
desc = f'Series complete for {self.team_name}. The series resulted in a {series_result_formatted}, and ended on the {series_yard_description} yard line. '
else:
desc = f'Series complete for {self.team_name}. The series resulted in a {series_result_formatted}, and ended on the 50 yard line. '
return desc
def toJSON(self):
return {
'type':'series',
'id': self.id,
'game_id': self.game_id,
'drive_id': self.drive_id,
'series_index': self.series_index,
'team_name': self.team_name,
'series_end_line': self.series_end_line,
'series_result': self.series_result,
'series_time_taken_sec': self.series_time_taken_sec,
'desc': self.get_description()
}
class OrderEvent(FinancialEvent):
"""An order-level financial event."""
id = db.Column(db.Integer, db.ForeignKey('financial_event.id', ondelete='CASCADE'), primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('order.id'))
order = db.relationship('Order', back_populates='financials')
def __repr__(self):
order_number = self.order.order_number if self.order else None
return f'<{type(self).__name__} {self.id}: ${self.net} {order_number}'
class Order(db.Model, SearchMixin):
"""Represents a transfer of inventory from one entity to another."""
id = db.Column(db.Integer, primary_key=True)
source_id = db.Column(db.Integer,
db.ForeignKey('entity.id', ondelete='RESTRICT'),
nullable=False)
dest_id = db.Column(db.Integer,
db.ForeignKey('entity.id', ondelete='RESTRICT'))
date = db.Column(db.DateTime, default=db.func.now())
order_number = db.Column(db.String(64))
source = db.relationship(
'Entity',
primaryjoin='Order.source_id == Entity.id',
back_populates='orders_from',
)
destination = db.relationship('Entity',
primaryjoin='Order.dest_id == Entity.id',
back_populates='orders_to')
items = db.relationship('OrderItem',
back_populates='order',
passive_deletes=True)
shipments = db.relationship('Shipment', back_populates='order')
financials = db.relationship('OrderEvent', back_populates='order')
def __repr__(self):
src_name = self.source.name if self.source else None
dest_name = self.destination.name if self.destination else None
return f'<{type(self).__name__} ({self.id}) {self.order_number} {src_name} -> {dest_name}>'
def send_inventory(self):
for item in self.items:
item.send_inventory()
def receive_inventory(self):
for item in self.items:
item.receive_inventory()
def charge_account(self, account):
for item in self.items:
item.charge_account(account)
def charge_transfer(self, account):
for item in self.items:
item.charge_transfer(account)
@property
def total(self):
order_cost = sum(e.net for e in self.financials)
item_cost = sum(sum(e.net for e in i.financials) for i in self.items)
return order_cost + item_cost
def profit(self):
profits = [i.profit() for i in self.items]
profits = [p for p in profits if p is not None]
return sum(profits)
class OrderItemEvent(FinancialEvent):
"""An order-item-level financial event."""
id = db.Column(db.Integer, db.ForeignKey('financial_event.id', ondelete='CASCADE'), primary_key=True)
item_id = db.Column(db.Integer, db.ForeignKey('order_item.id'))
item = db.relationship('OrderItem', back_populates='financials')
def __repr__(self):
if self.item:
return f'<{type(self).__name__} {self.id}: ${self.net} {self.item.quantity} x {self.item.source.listing.sku}>'
else:
return f'<{type(self).__name__} {self.id}: ${self.net}>'
class ForumThreadSubscription(db.Model, MultiPKMixin):
__tablename__ = 'forums_threads_subscriptions'
__cache_key_users__ = 'forums_threads_subscriptions_{thread_id}_users'
__cache_key_of_user__ = 'forums_threads_subscriptions_{user_id}'
user_id = db.Column(
db.Integer, db.ForeignKey('users.id'), primary_key=True
)
thread_id = db.Column(
db.Integer, db.ForeignKey('forums_threads.id'), primary_key=True
)
@classmethod
def new(
cls, *, user_id: int, thread_id: int
) -> Optional['ForumThreadSubscription']:
ForumThread.is_valid(thread_id, error=True)
User.is_valid(user_id, error=True)
cache.delete(cls.__cache_key_users__.format(thread_id=thread_id))
cache.delete(cls.__cache_key_of_user__.format(user_id=user_id))
return super()._new(user_id=user_id, thread_id=thread_id)
@classmethod
def user_ids_from_thread(cls, id: int) -> List[int]:
return cls.get_col_from_many(
key=cls.__cache_key_users__.format(thread_id=id),
column=cls.user_id,
filter=cls.thread_id == id,
)
@classmethod
def clear_cache_keys(
cls, user_ids: List[int] = None, thread_id: int = None
) -> None:
"""
Clear the cache keys associated with specific users and/or threads. Clearing a thread
cache key also clears the cache keys for all of its users
:param user_ids: The IDs of the users whose cache keys should be cleared
:param thread_id: The ID of the thread for which the cache key should be cleared
"""
user_ids = (
user_ids or []
) # Don't put a mutable object as default kwarg!
if thread_id:
cache.delete(cls.__cache_key_users__.format(thread_id=thread_id))
user_ids += cls.user_ids_from_thread(thread_id)
if user_ids:
cache.delete_many(
*(
cls.__cache_key_of_user__.format(user_id=uid)
for uid in user_ids
)
)
class PrivateMessage(db.Model, SinglePKMixin):
__tablename__ = 'pm_messages'
__cache_key__ = 'pm_messages_{id}'
__cache_key_of_conversation__ = 'pm_messages_conv_{conv_id}'
__serializer__ = PrivateMessageSerializer
id = db.Column(db.Integer, primary_key=True)
conv_id = db.Column(
db.Integer,
db.ForeignKey('pm_conversations.id'),
nullable=False,
index=True,
)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
time = db.Column(
db.DateTime(timezone=True),
nullable=False,
index=True,
server_default=func.now(),
)
contents = db.Column(db.Text, nullable=False)
@classmethod
def from_conversation(cls,
conv_id: int,
page: int = 1,
limit: int = 50) -> List['PrivateMessage']:
"""
Get a list of private messages in a conversation.
"""
return cls.get_many(
key=cls.__cache_key_of_conversation__.format(conv_id=conv_id),
filter=cls.conv_id == conv_id,
order=cls.id.asc(),
page=page,
limit=limit,
)
@classmethod
def new(cls, conv_id: int, user_id: int,
contents: str) -> Optional['PrivateMessage']:
"""
Create a message in a PM conversation.
"""
PrivateConversation.is_valid(conv_id, error=True)
User.is_valid(user_id, error=True)
PrivateConversationState.update_last_response_time(conv_id, user_id)
return super()._new(conv_id=conv_id,
user_id=user_id,
contents=contents)
@cached_property
def user(self):
return User.from_pk(self.user_id)
class InventoryAdjustment(FinancialEvent):
"""An inventory adjustment."""
id = db.Column(db.Integer, db.ForeignKey('financial_event.id', ondelete='CASCADE'), primary_key=True)
inv_id = db.Column(db.Integer, db.ForeignKey('inventory.id', ondelete='RESTRICT'), nullable=False)
inventory = db.relationship('Inventory', back_populates='adjustments')
quantity = db.Column(db.Integer)
def __repr__(self):
if self.inventory:
return f'<{type(self).__name__} ${self.net} {self.quantity}x {self.inventory.owner.name} {self.inventory.listing.sku}>'
else:
return f'<{type(self).__name__} ${self.net} {self.quantity}x >'
class Order(db.Model):
__tablename__ = 'orders'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = relationship("User", foreign_keys=user_id)
product_id = db.Column(db.Integer, db.ForeignKey('products.id'))
product = relationship("Product", foreign_keys=product_id)
count = db.Column(db.Integer)
description = db.Column(db.String(200))
date = db.Column(db.Integer)
state = db.Column(db.Integer)
cost = db.Column(db.Integer)
test_pass = db.Column(db.Integer)
class Jrnl(db.Model):
"""
A tinyjrnl entry created by an end user
"""
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, nullable=False)
entry = db.Column(db.Text)
channel_id = db.Column(db.Integer, db.ForeignKey('channel.id'))
account_id = db.Column(db.String(34), db.ForeignKey('user.account_id'))
tags = db.relationship('Tag',
secondary=jrnl_tags,
backref=db.backref('jrnls', lazy='dynamic'))
class Attendance(db.Model):
id = db.Column(db.Integer, primary_key=True)
attended = db.Column(db.Integer, nullable=False)
class_id = db.Column(db.Integer, db.ForeignKey('class.id'), nullable=False)
student_id = db.Column(db.Integer,
db.ForeignKey('student.id'),
nullable=False)
def __repr__(self):
return str(self.id)
class FinancialEvent(db.Model, PolymorphicMixin, SearchMixin):
"""Represents a financial event, like a debit or credit."""
id = db.Column(db.Integer, primary_key=True)
account_id = db.Column(db.Integer, db.ForeignKey('financial_account.id', ondelete='CASCADE'), nullable=False)
originator_id = db.Column(db.Integer, db.ForeignKey('entity.id'))
date = db.Column(db.DateTime, default=lambda: datetime.utcnow())
net = db.Column(CURRENCY)
description = db.Column(db.Text)
account = db.relationship('FinancialAccount', back_populates='events')
originator = db.relationship('Entity', back_populates='financials')
def __repr__(self):
return f'<{type(self).__name__} {self.net} {self.description}>'
class Todo(db.Model):
id = db.Column(db.Integer, primary_key=True)
userId = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref='todos')
title = db.Column(db.String(40), nullable=False)
completed = db.Column(db.Boolean(), default=False)
@staticmethod
def save(user_id, **kwargs):
todo = Todo(userId=user_id, **kwargs)
db.session.add(todo)
db.session.commit()
return todo
@staticmethod
def update(id, **kwargs):
todo = Todo.query.filter_by(id=id).update(kwargs)
db.session.commit()
return Todo.query.get(id)
@staticmethod
def delete(todo):
db.session.delete(todo)
db.session.commit()
return True
class Photo(db.Model):
id = db.Column(db.Integer, primary_key=True)
albumId = db.Column(db.Integer, db.ForeignKey('album.id'))
album = db.relationship('Album', backref='photos')
title = db.Column(db.String(40), nullable=False)
url = db.Column(db.String(40), nullable=False)
thumbnailUrl = db.Column(db.String(40), nullable=False)
@staticmethod
def save(**kwargs):
photo = Photo(**kwargs)
db.session.add(photo)
db.session.commit()
return photo
@staticmethod
def update(id, **kwargs):
photo = Photo.query.filter_by(id=id).update(kwargs)
db.session.commit()
return Photo.query.get(id)
@staticmethod
def delete(photo):
db.session.delete(photo)
db.session.commit()
return True
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
postId = db.Column(db.Integer, db.ForeignKey('post.id'))
post = db.relationship('Post', backref='comments')
name = db.Column(db.String(40), nullable=False)
email = db.Column(db.String(20), nullable=False)
body = db.Column(db.Text(), nullable=False)
@staticmethod
def save(**kwargs):
comment = Comment(**kwargs)
db.session.add(comment)
db.session.commit()
return comment
@staticmethod
def update(id, **kwargs):
comment = Comment.query.filter_by(id=id).update(kwargs)
db.session.commit()
return Comment.query.get(id)
@staticmethod
def delete(comment):
db.session.delete(comment)
db.session.commit()
return True
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
userId = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref='posts')
title = db.Column(db.String(40), nullable=False)
body = db.Column(db.Text(), nullable=False)
@staticmethod
def save(user_id, **kwargs):
post = Post(userId=user_id, **kwargs)
db.session.add(post)
db.session.commit()
return post
@staticmethod
def update(id, **kwargs):
post = Post.query.filter_by(id=id).update(kwargs)
if post:
db.session.commit()
return Post.query.filter_by(id=id).first()
@staticmethod
def delete(post):
db.session.delete(post)
db.session.commit()
return True
class ForumPollChoice(db.Model, SinglePKMixin):
__tablename__ = 'forums_polls_choices'
__serializer__ = ForumPollChoiceSerializer
__cache_key__ = 'forums_polls_choice_{id}'
__cache_key_of_poll__ = 'forums_polls_choices_poll_{poll_id}'
__cache_key_answers__ = 'forums_polls_{id}_answers'
id = db.Column(db.Integer, primary_key=True)
poll_id = db.Column(
db.Integer, db.ForeignKey('forums_polls.id'), nullable=False
)
choice = db.Column(db.Text, nullable=False)
@classmethod
def from_poll(cls, poll_id: int) -> List['ForumPollChoice']:
return cls.get_many(
key=cls.__cache_key_of_poll__.format(poll_id=poll_id),
filter=cls.poll_id == poll_id,
order=cls.id.asc(),
)
@classmethod
def new(cls, *, poll_id: int, choice: str) -> 'ForumPollChoice':
ForumPoll.is_valid(poll_id, error=True)
cache.delete(cls.__cache_key_of_poll__.format(poll_id=poll_id))
return cls._new(poll_id=poll_id, choice=choice)
@classmethod
def is_valid_choice(
cls, pk: int, poll_id: int, error: bool = False
) -> bool:
poll = ForumPoll.from_pk(poll_id, _404=True)
choice = ForumPollChoice.from_pk(pk, _404=True)
if poll.id != choice.poll_id:
if error:
raise APIException(
f'Poll {poll_id} has no answer choice {pk}.'
)
return False # pragma: no cover
return True
@cached_property
def poll(self) -> ForumPoll:
return ForumPoll.from_pk(self.poll_id)
@cached_property
def answers(self):
return self.count(
key=self.__cache_key_answers__.format(id=self.id),
attribute=ForumPollAnswer.user_id,
filter=ForumPollAnswer.choice_id == self.id,
)
def delete_answers(self):
db.session.execute(
ForumPollAnswer.__table__.delete().where(
ForumPollAnswer.choice_id == self.id
)
)
cache.delete(self.__cache_key_answers__.format(id=self.id))
class RelationshipSource(db.Model, PolymorphicMixin):
"""A listing on the 'many' side of the relationship."""
id = db.Column(db.Integer, primary_key=True)
relationship_id = db.Column(db.Integer,
db.ForeignKey('relationship.id',
ondelete='CASCADE'),
nullable=False)
listing_id = db.Column(db.Integer,
db.ForeignKey('listing.id', ondelete='CASCADE'),
nullable=False)
units = db.Column(CURRENCY, nullable=False, default=1)
relationship = db.relationship('Relationship', back_populates='sources')
listing = db.relationship('Listing')
__table_args__ = (UniqueConstraint('relationship_id', 'listing_id'), )
class Prise(db.Model):
__tablename__ = 'stock_price'
id = db.Column(db.Integer, primary_key=True)
tradedate = db.Column(db.DateTime)
secid = db.Column(db.String(5))
value = db.Column(db.Integer)
opens = db.Column(db.Integer)
low = db.Column(db.Integer)
high = db.Column(db.Integer)
close = db.Column(db.Integer)
stock_ticker_id = db.Column(db.Integer, db.ForeignKey('stock_ticker.id'))
def __init__(self,
tradedate=None,
secid=None,
value=None,
opens=None,
low=None,
high=None,
close=None,
stock_ticker_id=None):
self.tradedate = tradedate
self.secid = secid
self.value = value
self.opens = opens
self.low = low
self.high = high
self.close = close
self.stock_ticker_id = stock_ticker_id
def __repr__(self):
return '<Prise {} {} {} {} {} {} {}>'.format(self.tradedate,
self.secid, self.value,
self.opens, self.low,
self.high, self.close)
class Menu(db.Model):
__tablename__ = 'menu'
menu_id = db.Column(db.Integer, primary_key=True)
category_id = db.Column(db.Integer, db.ForeignKey('category.category_id'))
item_name = db.Column(db.String)
description = db.Column(db.String)
price = db.Column(db.Integer)
visibility = db.Column(db.Boolean)
position_in_menu = db.Column(db.Integer)
date_added = db.Column(db.DateTime)
total_calories = db.Column(db.Integer)
discount = db.Column(db.Integer)
category = db.relationship('Category')
imgfile = db.Column(db.String)
def __init__(self, category_id, item_name, description, price,
position_in_menu, imgfile):
self.category_id = category_id
self.item_name = item_name
self.description = description
self.price = price
self.visibility = True
self.position_in_menu = position_in_menu
self.total_calories = 0
self.discount = 0
self.imgfile = imgfile
class Class(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False)
photo = db.Column(db.String(250), nullable=True)
institution_id = db.Column(db.Integer,
db.ForeignKey('institution.id'),
nullable=False)
students = db.relationship(Student,
secondary=relation_student_class,
backref='classes')
grades = db.relationship('Grade',
backref='class',
lazy=True,
cascade="all, delete-orphan")
attendances = db.relationship('Attendance',
backref='class',
lazy=True,
cascade="all, delete-orphan")
events = db.relationship('Event',
backref='class',
lazy=True,
cascade="all, delete-orphan")
class Paciente(db.Model):
__tablename__ = "pacientes"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
dataNascimento = db.Column(db.String)
sexo = db.Column(db.String(1))
cidade = db.Column(db.String(50))
profissao = db.Column(db.String(50))
objetivo = db.Column(db.String(50))
user = db.relationship('User', foreign_keys=user_id)
def __init__(self, username, password, name, email, celular, dataNascimento, sexo, cidade, profissao, objetivo):
u = User(username, password, name, email, celular, "P")
db.session.add(u)
db.session.commit()
self.user_id = u.id
self.dataNascimento = dataNascimento
self.sexo = sexo
self.cidade = cidade
self.profissao = profissao
self.objetivo = objetivo
def __repr__(self):
return "<Paciente {0}>".format(self.user.username)
class UserPermission(db.Model, MultiPKMixin):
__tablename__ = 'users_permissions'
user_id: int = db.Column(
db.Integer, db.ForeignKey('users.id'), primary_key=True
)
permission: str = db.Column(db.String(36), primary_key=True)
granted: bool = db.Column(
db.Boolean, nullable=False, index=True, server_default='t'
)
all_permissions: List[str] = []
@classmethod
def from_user(cls, user_id: int, prefix: str = None) -> Dict[str, bool]:
"""
Gets a dict of all custom permissions assigned to a user.
:param user_id: User ID the permissions belong to
:return: Dict of permissions with the name as the
key and the ``granted`` value as the value
"""
return {
p.permission: p.granted
for p in cls.query.filter( # type: ignore
cls.user_id == user_id
).all()
if not prefix or p.permission.startswith(prefix)
}
class Order(db.Model):
__tablename__ = 'order'
id = db.Column(
INTEGER(unsigned=True),
primary_key=True,
autoincrement=True
)
user_id = db.Column(
INTEGER(unsigned=True),
db.ForeignKey(
"user.id",
ondelete='CASCADE',
onupdate='CASCADE'
),
nullable=False,
primary_key=True
)
vehicle_manufacturer = db.Column(db.String(16), nullable=False, unique=True)
model = db.Column(db.String(16), nullable=False)
price = db.Column(INTEGER())
currency = db.Column(db.String(3), nullable=False)
created = db.Column(
db.DateTime,
server_default=text('CURRENT_TIMESTAMP')
)
updated = db.Column(
db.DateTime,
server_default=text('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP')
)
__table_args__ = {'mysql_engine': 'InnoDB'}
__mapper_args__ = {'always_refresh': True}
def serialize(self):
return {
'id': self.id,
'vehicle_manufacturer': self.vehicle_manufacturer,
'model': self.model,
'price': self.price,
'currency': self.currency,
'created': Helper.date_format(self.created),
'updated': Helper.date_format(self.updated)
}
def get_by_id(self, order_id):
results = self.query.filter(self.__class__.id == order_id).first()
if results is None:
return None
return results.serialize()
def save_and_get_id(self):
self.save()
db.session.refresh(self)
return self.id
def save(self):
db.session.add(self)
db.session.commit()
class Subscriber(db.Model):
id = db.Column(db.Integer, primary_key=True)
chat_id = db.Column(db.VARCHAR(255), unique=True)
username = db.Column(db.VARCHAR(255), nullable=True)
first_name = db.Column(db.VARCHAR(255), nullable=True)
last_name = db.Column(db.VARCHAR(255), nullable=True)
subscription_id = db.Column(db.Integer,
db.ForeignKey('subscription.id'),
nullable=True)
def __init__(self,
chat_id,
username=None,
first_name=None,
last_name=None):
self.chat_id = chat_id
db.session.add(self)
db.session.commit()
@classmethod
def get_or_create(cls, chat_id, **kwargs):
subscriber = cls.query.filter_by(chat_id).first()
if subscriber:
return subscriber, False
else:
subscriber = cls(chat_id)
db.session.add(subscriber)
db.session.commit()
return subscriber, True
class NetworkEvent(Event):
__tablename__ = 'event_network'
event_id = db.Column(db.Integer, db.ForeignKey('event_base.id'), primary_key=True)
__mapper_args__ = {'polymorphic_identity': 'network', 'inherit_condition': (event_id == Event.id)}
src_ip = db.Column(db.String(255))
dest_ip = db.Column(db.String(255))
protocol = db.Column(db.String(255))
src_port = db.Column(db.Integer)
dest_port = db.Column(db.Integer)
payload = db.Column(db.String(10000))
signature = db.Column(db.String(255))
reference = db.Column(db.String(1000))
def __init__(self, source_module, timestamp=db.func.current_timestamp(), src_ip=None, dest_ip=None, protocol=None, src_port=None, dest_port=None, payload=None, signature=None, reference=None):
super(NetworkEvent, self).__init__(source_module, timestamp)
self.src_ip = src_ip
self.dest_ip = dest_ip
self.protocol = protocol
self.src_port = src_port
self.dest_port = dest_port
self.payload = payload
self.signature = signature
self.reference = reference
def __repr__(self):
return '<NetworkEvent {}>'.format(self.id)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(256))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
def __repr__(self):
return "<Post {}>".format(self.body)
