class AuthorBookModel(db.Model):
"""
Model of association between author and book.
"""
__tablename__ = 'author_book'
id: int = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer, db.ForeignKey("author.id"))
book_id = db.Column(db.Integer, db.ForeignKey("book.id"))
@staticmethod
def get_by_id(id: int):
return AuthorBookModel.query.filter_by(id=id).first()
@staticmethod
def filter_by_author_id(author_id: int):
return AuthorBookModel.query.filter_by(author_id=author_id).all()
@staticmethod
def filter_by_book_id(book_id: int):
return AuthorBookModel.query.filter_by(book_id=book_id).all()
@staticmethod
def list_all():
return AuthorBookModel.query.order_by(AuthorBookModel.name).all()
def save(self):
db.session.merge(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Transactions(db.Model):
id = db.Column(db.Integer, primary_key=True)
payment_method_id = db.Column(db.Integer,
db.ForeignKey('payment_method.id',
ondelete='CASCADE'),
nullable=False,
default=1)
shipment_method_id = db.Column(db.Integer,
db.ForeignKey('shipment_method.id',
ondelete='CASCADE'),
nullable=False,
default=1)
insurance_method_id = db.Column(db.Integer,
db.ForeignKey('insurance_method.id',
ondelete='CASCADE'),
nullable=False,
default=1)
shipment_price = db.Column(db.Float, default=100)
insurance_price = db.Column(db.Float, default=0)
total = db.Column(db.Float)
payment_status = db.Column(db.Integer, nullable=True)
receiver_name = db.Column(db.String(50))
receiver_phone = db.Column(db.String(14))
receiver_address = db.Column(db.String(500))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime, default=db.func.current_timestamp())
def __repr__(self):
return "<Transactions %r>" % self.id
class PostTag(db.Model):
__tablename__ = 'posts_tags'
post_id = db.Column(db.Integer, db.ForeignKey(
'posts.id', ondelete='cascade'), primary_key=True)
tag_id = db.Column(db.Integer, db.ForeignKey(
'tags.id', ondelete='cascade'), primary_key=True)
class UserCourseModel(db.Model):
__tablename__ = 'user_course'
user_course_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
course_id = db.Column(db.Integer,
db.ForeignKey('course.course_id',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
course = db.relationship('CourseModel', foreign_keys=course_id)
user = db.relationship('UserModel', foreign_keys=user_id)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class VenueGenre(db.Model):
__tablename__ = 'venue_genre'
genre_id = db.Column(db.Integer,
db.ForeignKey('genres.id'),
primary_key=True)
venue_id = db.Column(db.Integer,
db.ForeignKey('venues.id'),
primary_key=True)
genre = db.relationship('Genre',
backref=db.backref('venue_genre',
cascade='all, delete-orphan'))
venue = db.relationship('Venue',
backref=db.backref('venue_genre',
cascade='all, delete-orphan'))
__table_args__ = (db.UniqueConstraint(genre_id, venue_id), )
@classmethod
def delete_old(cls, venue_id, genres):
venues_to_delete = db.session.query(cls).filter_by(
venue_id=venue_id).filter(cls.genre_id.notin_(genres))
venues_to_delete.delete(synchronize_session=False)
@classmethod
def get_genres_ids(cls, venue_id):
results = cls.query.filter_by(venue_id=venue_id).all()
return [str(result.genre_id) for result in results]
def __repr__(self):
return f'<VenreGenre venue {self.venue_id} genre {self.genre_id}>'
class Update_change(Node_Base):
__tablename__ = 'update_change'
id = Column(db.Integer,primary_key=True, autoincrement=True)
update_id=Column(db.String(255), db.ForeignKey('updates.update_id'))
change_id= Column(db.String(255), db.ForeignKey('changes.change_id'))
def __repr__(self):
return "<Update_change(update_id='%s',change_id='%s')>" %(self.update_id,self.change_id)
class searchAdConfirmMoney(db.Model, BaseModelMixin):
__tablename__ = 'searchad_bra_client_order_confirm_money'
id = db.Column(db.Integer, primary_key=True)
client_order_id = db.Column(
db.Integer, db.ForeignKey('searchAd_bra_client_order.id')) # 客户合同
client_order = db.relationship(
'searchAdClientOrder', backref=db.backref('searchad_confirm_client_order', lazy='dynamic'))
order_id = db.Column(
db.Integer, db.ForeignKey('searchAd_bra_order.id')) # 客户合同
order = db.relationship(
'searchAdOrder', backref=db.backref('searchad_confirm_order', lazy='dynamic'))
money = db.Column(db.Float())
rebate = db.Column(db.Float())
year = db.Column(db.Integer)
Q = db.Column(db.String(2))
create_time = db.Column(db.DateTime)
__mapper_args__ = {'order_by': year.desc()}
def __init__(self, client_order, year, Q, order, money=0.0, rebate=0.0, create_time=None):
self.client_order = client_order
self.order = order
self.money = money
self.rebate = rebate
self.year = year
self.Q = Q
self.create_time = create_time or datetime.date.today()
@property
def time(self):
return str(self.year) + str(self.Q)
class Topic(db.Model, ModelMixin):
__tablename__ = 'topics'
id = db.Column(db.Integer, primary_key=True)
created_time = db.Column(db.Integer)
title = db.Column(db.String(64))
content = db.Column(db.Text())
clicked = db.Column(db.Integer)
visit_count = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
comments = db.relationship('Comment', backref='topic', lazy="dynamic")
top_node_id = db.Column(db.Integer, db.ForeignKey('top_nodes.id'))
node_id = db.Column(db.Integer, db.ForeignKey('nodes.id'))
def __init__(self, form):
self.created_time = timestamp()
self.clicked = 0
self.title = form.get('title', '')
self.content = form.get('content', '')
self.node_id = int(form.get('node', '0'))
node = Node.query.filter_by(id=self.node_id).first()
self.top_node_id = node.top_node_id
def validate(self):
if len(self.title) > 0:
return True
else:
return False
class searchAdClientOrderBill(db.Model, BaseModelMixin, CommentMixin):
__tablename__ = 'searchad_bra_client_order_bill'
id = db.Column(db.Integer, primary_key=True)
company = db.Column(db.String(100))
client_id = db.Column(db.Integer, db.ForeignKey('searchAd_client.id'))
client = db.relationship('searchAdClient', backref=db.backref('searchad_bra_client_bill', lazy='dynamic'))
medium_id = db.Column(db.Integer, db.ForeignKey('searchAd_medium.id'))
medium = db.relationship('searchAdMedium', backref=db.backref('searchad_bra_medium_bill', lazy='dynamic'))
resource_type = db.Column(db.Integer) # 推广形式
money = db.Column(db.Float(), default=0.0)
rebate_money = db.Column(db.Float(), default=0.0)
start = db.Column(db.Date)
end = db.Column(db.Date)
def __init__(self, company, client, medium, resource_type, money, rebate_money, start=None, end=None):
self.company = company
self.client = client
self.medium = medium
self.resource_type = resource_type
self.money = money or 0.0
self.rebate_money = rebate_money or 0.0
self.start = start or datetime.date.today()
self.end = end or datetime.date.today()
@property
def resource_type_cn(self):
return BILL_RESOURCE_TYPE_CN.get(self.resource_type)
class UserPromoModel(db.Model):
__tablename__ = "userpromo"
userpromo_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
promo_code = db.Column(db.String(8), db.ForeignKey('promocode.promo_code'))
userpromo_validity = db.Column(db.Date, nullable=False)
userpromo_used = db.Column(db.Boolean, default=False, nullable=False)
user = db.relationship('UsersModel')
promo = db.relationship('PromoCodeModel')
def __init__(self, user_id, promo_code, userpromo_validity,
userpromo_used):
self.user_id = user_id
self.promo_code = promo_code
self.userpromo_used = userpromo_used
self.userpromo_validity = userpromo_validity
def json(self):
return {
'userpromo_id': self.userpromo_id,
'promo_code': self.promo_code,
'user_id': self.user_id,
'userpromo_used': self.userpromo_used,
'userpromo_validity': str(self.userpromo_validity)
}
@classmethod
def find_by_id(cls, userpromo_id):
return cls.query.filter_by(userpromo_id=userpromo_id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Show(db.Model):
""" Show Model """
__tablename__ = 'shows'
id = db.Column(db.Integer, primary_key=True)
artist_id = db.Column(db.Integer,
db.ForeignKey('artists.id'),
nullable=False)
venue_id = db.Column(db.Integer,
db.ForeignKey('venues.id'),
nullable=False)
start_time = db.Column(db.DateTime, nullable=False)
venue = db.relationship('Venue')
artist = db.relationship('Artist')
def show_artist(self):
""" Returns a dictinary of artists for the show """
return {
'artist_id': self.artist_id,
'artist_name': self.artist.name,
'artist_image_link': self.artist.image_link,
# convert datetime to string
'start_time': self.start_time.strftime('%Y-%m-%d %H:%M:%S')
}
def show_venue(self):
""" Returns a dictinary of venues for the show """
return {
'venue_id': self.venue_id,
'venue_name': self.venue.name,
'venue_image_link': self.venue.image_link,
# convert datetime to string
'start_time': self.start_time.strftime('%Y-%m-%d %H:%M:%S')
}
class File(db.Model, Deletable):
__tablename__ = "files"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
uploaded_name = db.Column(db.String(255), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
folder_id = db.Column(db.Integer,
db.ForeignKey("folders.id"),
nullable=False)
user = db.relationship("User", foreign_keys=user_id)
folder = db.relationship(
"Folder",
foreign_keys=folder_id,
uselist=False,
lazy="select",
back_populates="files",
)
def __init__(self, user_id, name: str, folder_id: int) -> None:
extension = name.split(".")[-1]
self.user_id = user_id
self.name = name
self.uploaded_name = (str(user_id) + "-" + str(uuid4().hex) + "." +
extension)
self.folder_id = folder_id
def serialize(self) -> dict:
return {"id": self.id, "name": self.name}
class TransactionModel(db.Model):
__tablename__ = 'transaction'
transaction_id = db.Column(db.BigInteger,
primary_key=True,
autoincrement=True)
amount = db.Column(db.Float, nullable=False)
created_at = db.Column(db.TIMESTAMP,
server_default=db.func.current_timestamp())
author_account = db.Column(db.String(34),
db.ForeignKey('account.account_number',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
receiver_account = db.Column(db.String(34),
db.ForeignKey('account.account_number',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
author = db.relationship('AccountModel', foreign_keys=author_account)
receiver = db.relationship('AccountModel', foreign_keys=receiver_account)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Record(Entry, db.Model):
def __init__(self, user_id) -> None:
super().__init__()
self.user_id = user_id
__tablename__ = 'glycaemia_record'
user_id = db.Column(db.Integer,
db.ForeignKey('{}.id'.format(User.__tablename__)),
nullable=False)
state_id = db.Column(db.Integer,
db.ForeignKey('{}.id'.format(State.__tablename__)),
nullable=False)
state = db.relationship(State, backref="states")
value = db.Column(db.Integer, nullable=False)
comment = db.Column(db.String(250), nullable=True)
@classmethod
def findByUserEmail(cls, email):
return cls.query.join(User).filter(User.email == email).all()
@classmethod
def findByUserId(cls, user_id):
return cls.query.filter_by(user_id=user_id).order_by(
desc(Record.takenAt)).all()
@classmethod
def getById(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def deleteById(cls, id):
return cls.query.filter_by(id=id).delete()
class Commission(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User',
backref=db.backref('commission_user',
lazy='dynamic'),
foreign_keys=[user_id])
year = db.Column(db.Integer)
rate = db.Column(db.Float)
creator_id = db.Column(db.Integer, db.ForeignKey('user.id'))
creator = db.relationship('User',
backref=db.backref('commission_creator',
lazy='dynamic'),
foreign_keys=[creator_id])
create_time = db.Column(db.DateTime)
__table_args__ = (db.UniqueConstraint('user_id',
'year',
name='_commission_user_year'), )
__mapper_args__ = {'order_by': year.desc()}
def __init__(self,
user,
year=None,
rate=None,
creator=None,
create_time=None):
self.user = user
self.creator = creator
self.year = year or datetime.datetime.now().year
self.rate = rate or 0.0
self.create_time = datetime.date.today()
class Node(Node_Base):
__tablename__ = 'nodes'
node_id = Column(db.Integer, primary_key=True, autoincrement=True)
created_at = Column(db.DateTime)
updated_at = Column(db.DateTime)
deleted_at = Column(db.DateTime)
management_ip = Column(db.String(255))
ssh_user = Column(db.String(255))
ssh_password = Column(db.String(255))
status = Column(db.Text)
node_display_name = Column(db.String(255))
node_info_id = Column(db.String(255),
db.ForeignKey('node_infos.node_info_id'))
deployment_id = Column(db.Integer,
db.ForeignKey('deployments.deployment_id'))
node_type = Column(db.String(255))
node_info = relationship("Node_info")
deployment = relationship("Deployment")
service_infos = relationship("Service_info", back_populates="node")
node_roles = relationship("Node_role", back_populates="node")
def __repr__(self):
return "<Node(node_id='%s',created_at='%s',updated_at='%s',deleted_at='%s',management_ip='%s',ssh_user='******',ssh_password='******',status='%s',node_display_name='%s',node_info_id='%s',deployment_id='%s',node_type='%s')>" % (
self.node_id, self.created_at, self.updated_at, self.deleted_at,
self.management_ip, self.ssh_user, self.ssh_password, self.status,
self.node_display_name, self.node_info_id, self.deployment_id,
self.node_type)
class Alert(Node_Base):
__tablename__ = 'alert'
alertid = Column(db.String(255), primary_key=True, default=generate_uuid)
alarmRaisedTime = Column(db.BigInteger)
alarmChangedTime = Column(db.BigInteger)
alarmClearedTime = Column(db.BigInteger)
state = Column(db.String(45))
perceivedSeverity = Column(db.String(45))
eventTime = Column(db.Integer)
eventType = Column(db.String(255))
faultType = Column(db.String(255))
probableCause = Column(db.String(255))
isRootCause = Column(db.Integer)
correlatedAlarmId = Column(db.Integer)
faultDetails = Column(db.String(255))
deviceid = Column(db.Integer, db.ForeignKey('devicedetails.did'))
metricid = Column(db.Integer, db.ForeignKey('metricdetails.metricid'))
devicedetail = relationship("Devicedetail")
metricdetail = relationship("Metricdetail")
#
def __repr__(self):
return "<Alert(alertid='%s',alarmRaisedTime='%s',alarmChangedTime='%s',alarmClearedTime='%s',state='%s',perceivedSeverity='%s',eventTime='%s',eventType='%s',faultType='%s',probableCause='%s',isRootCause='%s',correlatedAlarmId='%s',faultDetails='%s',deviceid='%s',metricid='%s')>" % (
self.alertid, self.alarmRaisedTime, self.alarmChangedTime,
self.alarmClearedTime, self.state, self.perceivedSeverity,
self.eventTime, self.eventType, self.faultType, self.probableCause,
self.isRootCause, self.correlatedAlarmId, self.faultDetails,
self.deviceid, self.metricid)
class Defense(db.Model):
__tablename__ = 'defense'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String)
description = db.Column(db.String())
ability_id = db.Column(db.Integer, db.ForeignKey('abilities.id'))
modifier_id = db.Column(db.Integer, db.ForeignKey('modifiers.id'))
all = db.Column(db.Boolean)
current = db.Column(db.Boolean)
any = db.Column(db.Boolean)
var = db.Column(db.Boolean)
none = db.Column(db.Boolean)
hide = db.Column(db.Boolean)
power = db.Column(db.Boolean)
active = db.Column(db.Boolean)
def format(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'ability_id': self.ability_id,
'modifier_id': self.modifier_id,
'all': self.all,
'current': self.current,
'any': self.any,
'var': self.var,
'none': self.none,
'hide': self.hide,
'power': self.power,
'active': self.active
}
class CardModel(db.Model):
__tablename__ = 'card'
card_number = db.Column(db.String(17), primary_key=True)
amount = db.Column(db.Float, nullable=False)
active_to = db.Column(db.DATE, nullable=False)
cvv = db.Column(db.SmallInteger, nullable=False)
created_at = db.Column(db.TIMESTAMP,
server_default=db.func.current_timestamp())
owner_id = db.Column(db.Integer,
db.ForeignKey('user.user_id',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
account_number = db.Column(db.String(34),
db.ForeignKey('account.account_number',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
owner = db.relationship('UserModel', foreign_keys=owner_id)
account = db.relationship('AccountModel', foreign_keys=account_number)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class SkillTable(db.Model):
__tablename__ = 'skill_tables'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
skill_id = db.Column(db.Integer, db.ForeignKey('skills.id'))
dc = db.Column(db.Integer)
description = db.Column(db.String())
check_id = db.Column(db.Integer, db.ForeignKey('checks.id'))
modifier_id = db.Column(db.Integer, db.ForeignKey('modifiers.id'))
degree = db.Column(db.Boolean)
measurement = db.Column(db.Integer)
complexity = db.Column(db.String())
modifier = db.Column(db.Boolean)
circumstance = db.Column(db.Boolean)
requires_sub = db.Column(db.Boolean)
def format(self):
return {
'id': self.id,
'skill_id': self.skill_id,
'dc': self.dc,
'description': self.description,
'check_id': self.check_id,
'modifier_id': self.modifier_id,
'degree': self.degree,
'measurement': self.measurement,
'complexity': self.complexity,
'modifier': self.modifier,
'circumstance': self.circumstance,
'requires_sub': self.requires_sub
}
class PerformanceUser(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User',
backref=db.backref('performance_user',
lazy='dynamic'))
performance = db.relationship('Performance',
backref=db.backref('performance_user_money',
lazy='dynamic'))
performance_id = db.Column(db.Integer, db.ForeignKey('performance.id'))
year = db.Column(db.Integer)
q_month = db.Column(db.String(10))
money = db.Column(db.Float) # 销售目标
create_time = db.Column(db.DateTime)
__mapper_args__ = {'order_by': create_time.desc()}
def __init__(self, user, year, q_month, money, create_time, performance):
self.user = user
self.year = year
self.performance = performance
self.q_month = q_month
self.money = money
self.create_time = create_time or datetime.date.today()
@property
def status(self):
return self.performance.status
class Descriptor(db.Model):
__tablename__ = 'descriptors'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String())
origin = db.Column(db.Integer, db.ForeignKey('origin.id'))
source = db.Column(db.Integer, db.ForeignKey('source.id'))
medium = db.Column(db.Integer, db.ForeignKey('medium.id'))
medium_type = db.Column(db.Integer, db.ForeignKey('medium_type.id'))
medium_subtype = db.Column(db.Integer, db.ForeignKey('medium_subtype.id'))
result = db.Column(db.String())
description = db.Column(db.String())
damage = db.Column(db.Boolean)
rarity = db.Column(db.String())
show = db.Column(db.Boolean)
approved = db.Column(db.Boolean)
def format(self):
return {
'id': self.id,
'name': self.name,
'origin': self.origin,
'source': self.source,
'medium': self.medium,
'medium_type': self.medium_type,
'medium_subtype': self.medium_subtype,
'result': self.result,
'description': self.description,
'damage': self.damage,
'rarity': self.rarity
}
class Device(db.Model):
__tablename__ = 'device'
id = db.Column(db.Integer, primary_key=True)
device_id = db.Column(db.Unicode)
device_name = db.Column(db.Unicode)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
add_date = db.Column(db.DateTime)
token_id = db.Column(db.Integer, db.ForeignKey(Token.id))
last_logged_in = db.Column(db.DateTime)
token = db.relationship('Token', uselist=False)
def addDevice(self, params):
self.device_name = params[
'device_name'] if 'device_name' in params else None
self.device_id = params['device_id']
self.user_id = params['user_id']
self.token_id = params['token_id']
db.session.add(self)
db.session.commit()
return self
def getDeviceByDeviceId(self, params):
device = self.query.filter_by(device_id=params['device_id']).first()
if device is None:
raise ErrorWithCode(404, "This device is not signed up before")
return device
def getDevice(self, params):
device = None
if 'token' in params:
device = self.query.join(Token).filter(
Token.token == params['token']).filter(
datetime.now() < Token.expiry).first()
return device
class HasOwner(db.Model):
__tablename__ = 'has_owner'
inventoryID = db.Column(db.Integer,
db.ForeignKey('inventorys.id', ondelete="CASCADE"),
primary_key=True)
ownerID = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"),
primary_key=True)
class Modifications(db.Model):
id = db.Column(db.Integer, primary_key=True)
series_id = db.Column(db.Integer, db.ForeignKey('series.id'))
model_id = db.Column(db.Integer, db.ForeignKey('model.id'))
name = db.Column(db.String(256), index=True)
year_begin = db.Column(db.String(128), index=True)
year_end = db.Column(db.String(128), index=True)
class HasTags(db.Model):
__tablename__ = 'has_tags'
tagID = db.Column(db.Integer,
db.ForeignKey('tags.id', ondelete="CASCADE"),
primary_key=True)
deviceID = db.Column(db.Integer,
db.ForeignKey('devices.id', ondelete="CASCADE"),
primary_key=True)
class Job_HasEvents(db.Model):
__tablename__ = 'job_hasEvents'
jobID = db.Column(db.Integer,
db.ForeignKey('jobs.id', ondelete="CASCADE"),
primary_key=True)
eventID = db.Column(db.Integer,
db.ForeignKey('events.id', ondelete="CASCADE"),
primary_key=True)
class UserGrades(db.Model):
__tablename__ = 'user_grades'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
user = db.relationship("User", backref=db.backref('grades', order_by=id))
assignment_id = db.Column(db.Integer(), db.ForeignKey('assignment.id'))
assignment = db.relationship("Assignment",
backref=db.backref('grades', order_by=id))
score = db.Column(db.Numeric())
class Service_info_File_config(Node_Base):
__tablename__ = 'service_info_file_config'
id = Column(db.Integer, primary_key=True, autoincrement=True)
service_id = Column(db.Integer, db.ForeignKey('service_infos.service_id'))
file_config_id = Column(db.Integer, db.ForeignKey('file_configs.file_id'))
def __repr__(self):
return "<Service_info_File_config(service_id='%s',file_config_id='%s')>" % (
self.service_id, self.file_config_id)
class AccountManager(BaseUser, UserMixin, SuspendMixin):
__tablename__ = 'account_managers'
id = db.Column(db.BigInteger, db.ForeignKey('base_users.id'), primary_key=True, autoincrement=False)
restaurant_id = db.Column(db.BigInteger, db.ForeignKey('restaurants.id'))
__mapper_args__ = {
'polymorphic_identity': 'manager',
}
