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)