class Transaction(db.Model):
"""
Class for Transactions table
"""
__tablename__ = 'transactions'
id = db.Column(db.Integer, primary_key=True)
amount = db.Column(db.Numeric(), nullable=False)
paid_on = db.Column(db.DateTime)
payment_status = db.Column(db.Enum(PaymentStatus))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
expense_id = db.Column(db.Integer,
db.ForeignKey('expenses.id'),
nullable=False)
updated_at = db.Column(db.DateTime)
user = db.relationship('User', back_populates='transaction')
expense = db.relationship('Expense', back_populates='transaction')
def __init__(self, expense_id, user_id, amount):
self.amount = Decimal(amount)
self.user_id = user_id
self.expense_id = expense_id
self.payment_status = PaymentStatus.PENDING
self.update_at = datetime.datetime.now()
def __repr__(self):
return f'<Transaction {self.id}>'
class TbRole(db.Model):
"""
角色表
"""
__tablename__ = "tb_role"
id = db.Column(db.Integer, primary_key=True, comment="自增 id", autoincrement=True)
name = db.Column(db.String(64), comment="角色名")
interface = db.relationship(
"TbInterface",
secondary=interface,
lazy="subquery",
backref=db.backref("roles", lazy=True)
)
menu = db.relationship(
"TbMenu",
secondary=menu,
lazy="subquery",
backref=db.backref("roles", lazy=True))
create_time = db.Column(db.BigInteger, default=utc_timestamp, comment="创建时间")
creator_code = db.Column(db.String(32), db.ForeignKey("tb_user.code"))
business_code = db.Column(db.String(32), db.ForeignKey("tb_business.code"))
code = db.Column(db.String(32), comment="角色号", unique=True)
merchant_code = db.Column(db.String(32), db.ForeignKey("tb_merchant.code"))
def __repr__(self):
return "角色表 {}".format(self.name)
class Purchase(db.Model):
__tablename__ = 'purchase'
id = db.Column(db.Integer, primary_key=True)
status_id = db.Column(db.Integer, db.ForeignKey(
'purchase_status.id'), default=1, nullable=False)
buyer_id = db.Column(db.Integer, db.ForeignKey(
'user.id'), default=1, nullable=False)
total = db.Column(db.Float, default=0)
created_date = db.Column(db.DateTime, default=datetime.now, nullable=False)
updated_date = db.Column(db.DateTime, default=datetime.now)
isActive = db.Column(db.Boolean, default=True)
purchase_items = db.relationship(
"P_Item", backref="purchase", lazy="dynamic")
# TODO keep track of time when status change to determine timelapse between status.
def __init__(self, **kwargs):
super().__init__(**kwargs)
def __repr__(self):
return f"Purchase {self.id} - Buyer:{self.buyer_id}."
# calculate total of order
def set_total(self):
amt = 0
for item in self.purchase_items:
amt = amt + float(item.product.price)*item.qty
return amt
class EventInvitee(db.Model):
id = db.Column(UUIDType(binary=False), default=generate_uuid)
date_invited = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
event_id = db.Column(UUIDType(binary=False),
db.ForeignKey('event.id'),
primary_key=True,
nullable=False)
invitee_id = db.Column(UUIDType(binary=False),
db.ForeignKey('invitee.id'),
primary_key=True,
nullable=False)
message_recipients = db.relationship('MessageRecipient',
backref='event_invitee',
lazy=True,
cascade="delete")
def __repr__(self):
return f"EventInvitee('{self.event_id}', '{self.invitee_id}', '{self.date_invited}')"
def serialize(self):
return {
"id":
self.id,
"date_invited":
self.date_invited,
"event_id":
self.event_id,
"invitee_id":
self.invitee_id,
"message_recipients":
[recipient.id for recipient in self.message_recipients]
}
class Message(db.Model):
id = db.Column(db.String(34), primary_key=True)
sms_content = db.Column(db.String(1600), nullable=False)
date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
creator_id = db.Column(UUIDType(binary=False),
db.ForeignKey('user.id'),
nullable=False)
parent_message_id = db.Column(db.String(34),
db.ForeignKey('message.id'),
nullable=True)
message_recipients = db.relationship('MessageRecipient',
backref='message',
lazy=True,
cascade="delete")
def __repr__(self):
return f"Message('{self.sms_content}', '{self.date_created}')"
def serialize(self):
return {
"id":
self.id,
"sms_content":
self.sms_content,
"date_created":
self.date_created,
"creator_id":
self.creator_id,
"parent_message_id":
self.parent_message_id,
"message_recipients":
[recipient.id for recipient in self.message_recipients]
}
class MessageRecipient(db.Model):
id = db.Column(UUIDType(binary=False),
primary_key=True,
default=generate_uuid)
date_received = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
recipient_id = db.Column(UUIDType(binary=False),
db.ForeignKey('invitee.id'))
recipient_group_id = db.Column(UUIDType(binary=False),
db.ForeignKey('event_invitee.id'))
message_id = db.Column(db.String(34),
db.ForeignKey('message.id'),
nullable=False)
response = db.Column(db.String(1600))
def __repr__(self):
return f"MessageRecipient('{self.recipient_id}', '{self.recipient_group_id}', '{self.response}', '{self.date_received}')"
def serialize(self):
return {
"id": self.id,
"date_received": self.date_received,
"recipient_id": self.recipient_id,
"recipient_group_id": self.recipient_group_id,
"message_id": self.message_id,
"response": self.response
}
class ItemAddOn(BaseMixin, db.Model, ReprMixin):
item_id = db.Column(UUID, db.ForeignKey('item.id'), index=True)
add_on_id = db.Column(UUID, db.ForeignKey('add_on.id'), index=True)
add_on = db.relationship('AddOn', foreign_keys=[add_on_id])
item = db.relationship('Item', back_populates='add_ons', foreign_keys=[item_id])
class QuoteItem(db.Model):
__tablename__ = 'quote_items'
id = db.Column(db.Integer, primary_key=True)
product_quantity = db.Column(db.Integer, nullable=False)
product_price = db.Column(db.Integer, nullable=False)
product_id = db.Column(db.Integer,
db.ForeignKey('products.id'),
nullable=False)
quote_id = db.Column(db.Integer,
db.ForeignKey('quotes.id'),
nullable=False)
def __init__(self,
id=None,
product_quantity=None,
product_price=None,
product_id=None,
quote_id=None):
self.id = id
self.product_quantity = product_quantity
self.product_price = product_price
self.product_id = product_id
self.quote_id = quote_id
class Ratings(db.Model): # rating or like???
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
event_id = db.Column(db.Integer, db.ForeignKey('event.id'), nullable=False)
stars = db.Column(db.Integer, nullable=False)
user = db.relationship('User', backref='user', lazy=True)
event = db.relationship('Event', backref='event', lazy=True)
class Message(db.Model):
__tablename__ = 'messages'
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.Text, nullable=False)
chat_id = db.Column(db.Integer, db.ForeignKey('chats.id'), nullable=False)
chat = db.relationship('Chat', backref=db.backref('messages', lazy=True))
created_by = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
db.CheckConstraint(
'created_by == chat.created_by OR created_by chat.participant')
def __init__(self, text, chat_id, created_by):
self.text = text
self.chat_id = chat_id
self.created_by = created_by
def __repr__(self):
return '<Message %s>'.format(self.text)
@staticmethod
def create(text, chat_id, user_id):
message = Message(text, chat_id, user_id)
db.session.add(message)
db.session.commit()
class Comment(db.Model, ResourceMixin):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
user_id = db.Column(
db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE', onupdate='CASCADE'))
post_id = db.Column(
db.Integer,
db.ForeignKey('posts.id', ondelete='CASCADE', onupdate='CASCADE'))
comment_id = db.Column(db.Integer,
db.ForeignKey('comments.id', ondelete='SET NULL'))
replies = db.relationship('Comment', lazy='joined')
likes = db.relationship('User',
secondary=comment_likes,
lazy='dynamic',
backref=db.backref('comment_likes',
lazy='dynamic'))
def __repr__(self):
return f'<Post {self.body}>'
def is_liked_by(self, user):
return self.likes.filter(
comment_likes.c.user_id == user.id).count() > 0
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String, nullable=False)
created_on = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
updated_on = db.Column(db.DateTime(timezone=True),
server_default=db.func.now(),
server_onupdate=db.func.now())
user_id = db.Column(db.Integer, db.ForeignKey(Users.id), nullable=False)
post_id = db.Column(db.Integer,
db.ForeignKey(Post.id, ondelete='CASCADE'),
nullable=False)
like_list = db.relationship('Like',
backref=db.backref('comment'),
passive_deletes="all",
lazy=True)
def render(self):
likes = [like.render() for like in self.like_list]
likers = [like['owner'] for like in likes]
return {
'comment_id': self.id,
'content': self.content,
'owner': self.user.user_name,
'owner_id': self.user.id,
"likes": {
'count': len(likes),
'liker_name': [like['owner'].user_name for like in likes],
'liker_id': [like['owner'].id for like in likes]
},
"created_on": self.created_on,
"updated_on": self.updated_on,
}
class ProductTax(db.Model, BaseMixin, ReprMixin):
tax_id = db.Column(db.Integer, db.ForeignKey('tax.id'))
product_id = db.Column(db.Integer, db.ForeignKey('product.id'))
tax = db.relationship('Tax', foreign_keys=[tax_id])
product = db.relationship('Product', foreign_keys=[product_id])
class RoleMenu(db.Model):
"""Hold the Role Menu Details."""
__tablename__ = 'nav_roles_menus'
role_menu_id = db.Column(db.Integer, primary_key=True)
menu_id = db.Column(db.Integer, db.ForeignKey('nav_menus.menu_id'),
nullable=False, primary_key=True)
role_id = db.Column(db.Integer, db.ForeignKey('sec_roles.role_id'),
nullable=False, primary_key=True)
can_view = db.Column(db.Boolean(), nullable=False, server_default='True')
can_create = db.Column(db.Boolean(), nullable=False, server_default='0')
can_edit = db.Column(db.Boolean(), nullable=False, server_default='0')
can_delete = db.Column(db.Boolean(), nullable=False, server_default='0')
is_active = db.Column(db.Boolean(), nullable=False, server_default='True')
created_by = db.Column(db.Integer)
created_datetime = db.Column(db.DateTime, default=datetime.now())
modified_by = db.Column(db.Integer)
last_modified_datetime = db.Column(db.DateTime, nullable=True)
def __init__(self, menu_id, role_id, created_by):
"""Create a new role menu combination."""
self.menu_id = menu_id
self.role_id = role_id
self.created_by = created_by
self.created_datetime = datetime.now()
self.can_view = True
class Like(db.Model):
id = db.Column(db.Integer, primary_key=True)
userid = db.Column(db.Integer, db.ForeignKey('user.id'))
tweetid = db.Column(db.Integer, db.ForeignKey('tweet.id'))
def __repr__(self):
return '<Like {},{}>'.format(self.userid, self.tweetid)
class Entry(db.Model):
id = db.Column(db.Integer, primary_key=True)
product_id = db.Column(db.Integer, db.ForeignKey('product.id'))
location_id = db.Column(db.Integer, db.ForeignKey('location.id'))
# Decimal(10,2) is a number with 8 digits before the decimal and 2 digts after
price = db.Column(db.Float(10, 2))
date = db.Column(db.DateTime)
class Winner(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True,
nullable=False)
user = db.relationship('User', backref='winners')
prize_id = db.Column(db.Integer,
db.ForeignKey('prize.id'),
index=True,
nullable=False)
prize = db.relationship('Prize', backref='winners')
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, user=None, prize=None, prize_id=None):
if prize_id:
self.prize_id = prize_id
else:
self.prize = prize
self.user = user
def __repr__(self):
return '<Winner id={}, user_id={}, prize_id={}, is_destroyed={}, created_at={}>'.format(
self.id, self.user_id, self.prize_id, self.is_destroyed,
self.created_at)
class CartItem(db.Model):
id = db.Column(UUIDType(binary=False), default=generate_uuid)
date_added = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
quantity = db.Column(db.Integer(), nullable=False)
cart_id = db.Column(UUIDType(binary=False),
db.ForeignKey('cart.id'),
primary_key=True,
nullable=False)
product_id = db.Column(UUIDType(binary=False),
db.ForeignKey('product.id'),
primary_key=True,
nullable=False)
def __repr__(self):
return f"CartItem('{self.id}', '{self.cart_id}', '{self.product_id}', '{self.date_added}', '{self.quantity}')"
def serialize(self):
return {
"id": self.id,
"quantity": self.quantity,
"date_added": self.date_added,
"cart_id": self.cart_id,
"product_id": self.product_id
}
class Prize(db.Model):
id = db.Column(db.Integer, primary_key=True)
challenge_id = db.Column(db.Integer,
db.ForeignKey('challenge.id'),
index=True,
nullable=False)
challenge = db.relationship('Challenge', backref='prizes')
sponsor_id = db.Column(db.Integer,
db.ForeignKey('sponsor.id'),
index=True,
nullable=False)
sponsor = db.relationship('Sponsor', backref='prizes')
name = db.Column(db.String(240), nullable=False)
count = db.Column(db.Integer, default=1)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, challenge, sponsor, name, count):
self.challenge = challenge
self.sponsor = sponsor
self.name = name
self.count = count
def __repr__(self):
return '<Prize id={}, challenge_id={}, sponsor_id={}, count={} is_destroyed={}, created_at={}>'.format(
self.id, self.challenge_id, self.sponsor_id, self.count,
self.is_destroyed, self.created_at)
class Ficha(Base):
__tablename__ = 'ficha'
# Chave
id = db.Column(db.Integer, primary_key=True)
paciente_cpf = db.Column(db.String(len_cpf), db.ForeignKey('paciente.cpf'))
medico_cpf = db.Column(db.String(len_cpf), db.ForeignKey('medico.cpf'))
sala_id = db.Column(db.Integer, db.ForeignKey('sala.id'))
# Atributos
comentarios = db.Column(db.String(500))
sintomas = db.Column(db.String(500))
exames = db.Column(db.String(500))
# Relações
paciente = db.relationship('Paciente', back_populates='fichas')
medico = db.relationship('Medico', back_populates='fichas')
sala = db.relationship('Sala', back_populates='fichas')
def __init__(self, paciente_cpf, medico_cpf, sala_id):
self.paciente_cpf = paciente_cpf
self.medico_cpf = medico_cpf
self.sala_id = sala_id
def __repr__(self):
return ("[Ficha] ID: " + self.id + "\n\t-paciente_cpf: " +
self.paciente_cpf + "\n\t-medico_cpf: " + self.medico_cpf +
"\n\t-sala_id: " + self.sala_id + "\n\t-comentarios: " +
self.comentarios + "\n\t-sintomas: " + self.sintomas +
"\n\t-exames: " + self.exames)
class Friendship(db.Model):
"""
Class for friendship table between users
params:
- status - ['accepted', 'rejected', 'pending']
"""
__tablename__ = 'friendships'
id = db.Column(db.Integer, primary_key=True)
friend1_id = db.Column(db.Integer, db.ForeignKey(
'users.id'), nullable=False)
friend2_id = db.Column(
db.Integer, db.ForeignKey('users.id'), nullable=False)
status = db.Column(db.String, nullable=False)
updated_at = db.Column(db.DateTime)
friend1 = db.relationship('User', backref='friendship1',
uselist=False, foreign_keys='[Friendship.friend1_id]')
friend2 = db.relationship('User', backref='friendship2',
uselist=False, foreign_keys='[Friendship.friend2_id]')
def __init__(self, friend1_id, friend2_id):
self.friend1_id = friend1_id
self.friend2_id = friend2_id
self.status = 'pending'
self.updated_at = datetime.datetime.now()
class Order(db.Model):
timestamp = db.Column(db.DateTime(timezone=True),
server_default=func.now())
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
restaurant_id = db.Column(db.Integer, db.ForeignKey('restaurant.id'))
status = db.Column(db.Integer, default=0) # payment or not yet
class Transaction(db.Model):
__tablename__ = 'transactions'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date, nullable=False)
total = db.Column(db.Integer, nullable=False)
customer_id = db.Column(db.Integer,
db.ForeignKey('customers.id'),
nullable=False)
quote_id = db.Column(db.Integer,
db.ForeignKey('quotes.id'),
nullable=False)
def __init__(self,
id=None,
date=None,
total=None,
customer_id=None,
quote_id=None):
self.id = id
self.date = date
self.total = total
self.customer_id = customer_id
self.quote_id = quote_id
class ProfilePermission(db.Model):
__tablename__ = 'profilePermission'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
profile_system_id = db.Column(db.Integer,
db.ForeignKey("profileSystem.id"),
nullable=False)
system_permission_id = db.Column(db.Integer,
db.ForeignKey("systemPermission.id"),
nullable=False)
creation_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow())
systemPermission = db.relationship("SystemPermission",
back_populates="profilePermission")
profileSystem = db.relationship("ProfileSystem",
back_populates="profilePermission")
def __init__(self, data):
self.system_permission_id = data.get('system_permission_id')
self.profile_system_id = data.get('profile_system_id')
def __repr__(self):
return f'<ProfilePermission: {self.id}'
class CheckInAnswer(db.Model):
id = db.Column(db.Integer, primary_key=True)
check_in_question_id = db.Column(db.Integer,
db.ForeignKey('check_in_question.id'),
index=True,
nullable=False)
check_in_question = db.relationship('CheckInQuestion',
backref='check_in_answers')
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True,
nullable=False)
user = db.relationship('User', backref='check_in_answers')
text = db.Column(db.Text(), nullable=False)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self,
user,
text,
check_in_question=None,
check_in_question_id=None):
if check_in_question_id:
self.check_in_question_id = check_in_question_id
else:
self.check_in_question = check_in_question
self.user = user
self.text = text
def __repr__(self):
return '<CheckInAnswer id={}, check_in_question_id={}, user_id={}, is_destroyed={}, created_at={}>'.format(
self.id, self.check_in_question_id, self.user_id,
self.is_destroyed, self.created_at)
class RetailBrandAddress(db.Model, BaseMixin, ReprMixin):
retail_brand_id = db.Column(db.Integer, db.ForeignKey('retail_brand.id'))
address_id = db.Column(db.Integer, db.ForeignKey('address.id'))
retail_brand = db.relationship('RetailBrand', foreign_keys=[retail_brand_id])
address = db.relationship('Address', foreign_keys=[address_id])
UniqueConstraint(retail_brand_id, address_id)
class OrderStatus(BaseMixin, db.Model, ReprMixin):
__repr_fields__ = ['order_id', 'status_id']
order_id = db.Column(UUID, db.ForeignKey('order.id'), nullable=False, index=True)
status_id = db.Column(UUID, db.ForeignKey('status.id'), nullable=False, index=True)
order = db.relationship('Order', foreign_keys=[order_id])
status = db.relationship('Status', foreign_keys=[status_id])
class Review(db.Model):
id = db.Column(db.Integer, primary_key=True)
rating = db.Column(db.Integer, nullable=True)
text = db.Column(db.String, nullable=False)
created_at = db.Column(db.DateTime, default = datetime.utcnow, server_default= db.func.now())
user_id = db.Column(db.Integer, db.ForeignKey('user_visit.id'), nullable=False)
team_id = db.Column(db.Integer, db.ForeignKey('team.id'))
campaign_id = db.Column(db.Integer, db.ForeignKey('campaign.id'))
class OrderDiscount(BaseMixin, db.Model, ReprMixin):
__repr_fields__ = ['order_id', 'discount_id']
order_id = db.Column(UUID, db.ForeignKey('order.id'), nullable=False, index=True)
discount_id = db.Column(UUID, db.ForeignKey('discount.id'), nullable=False, index=True)
order = db.relationship('Order', foreign_keys=[order_id])
discount = db.relationship('Discount', foreign_keys=[discount_id])
class WatchList(db.Model):
id = db.Column(db.Integer, primary_key=True)
status = db.Column(db.Boolean, nullable=False, default=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
item_id = db.Column(db.Integer, db.ForeignKey('item.id'), nullable=False)
def __repr__(self):
return f"WatchList(''{self.id},'{self.status}')"
