class TodoModel(Base):
__tablename__ = 'todos'
id = db.Column(db.Integer, primary_key=True)
desc = db.Column(db.String(200))
done = db.Column(db.Boolean())
project_id = db.Column(db.Integer, db.ForeignKey('projects.id'))
project = db.relationship('ProjectModel')
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('UserModel')
def __init__(self, desc, done, project_id=None, user_id=None):
self.desc = desc
self.done = done
self.project_id = project_id
self.user_id = user_id
def json(self):
return {
'id':
self.id,
'desc':
self.desc,
'done':
self.done,
'project':
self.project.query.filter_by(id=self.project_id).first().name,
'created_by':
self.user.query.filter_by(id=self.user_id).first().username
}
class UserModel(Base):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(80))
oauth = db.Column(db.Boolean())
todos = db.relationship('TodoModel', lazy='dynamic')
projects = db.relationship('ProjectModel', lazy='dynamic')
def __init__(self, username, password=None, oauth=False):
self.username = username
if password:
self.password = generate_password_hash(password).decode('utf-8')
else:
self.password = password
self.oauth = oauth
def json(self):
return {
'id': self.id,
'username': self.username,
'todos': [todo.json() for todo in self.todos.all()]
}
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
class Agency(db.Model):
"""
The model of agency
"""
id = db.Column(db.Integer,
autoincrement=True,
nullable=False,
primary_key=True,
unique=True)
name = db.Column(db.String(50), nullable=False)
introduction = db.Column(db.Text, nullable=True)
city = db.Column(db.String(20), nullable=False)
address = db.Column(db.String(200), nullable=False)
phone = db.Column(db.String(15), nullable=False)
certification = db.Column(db.Boolean, nullable=False, default=False)
create_time = db.Column(db.DateTime, nullable=False)
last_update = db.Column(db.DateTime, nullable=True)
avator = db.Column(db.Integer, db.ForeignKey("image.id"), nullable=False)
trust_orders = db.relationship("TrusteeshipOrder", backref='agency')
images = db.relationship("Image",
secondary=agency_image,
lazy='subquery',
backref=db.backref('image_of', lazy=True))
managers = db.relationship("User", backref="own_agency")
comments = db.relationship("Comment", backref="comment_for")
counter = db.relationship("Counter", backref="counter_for")
class Role(db.Model):
'''
权限
'''
__tablename__ = 'db_role'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
index=True,
autoincrement=True)
role_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
name = db.Column(db.String(64), nullable=False, unique=True)
mark = db.Column(db.String(64), nullable=False, unique=True)
is_disabled = db.Column(db.Boolean, index=True, default=False)
admins = db.relationship('Admin', backref='role')
menus = db.relationship('Menu',
secondary=MenuToRole,
backref=db.backref('db_role', lazy='dynamic'),
lazy='dynamic')
interfaces = db.relationship('Interface',
secondary=InterfaceToRole,
backref=db.backref('db_interface',
lazy='dynamic'),
lazy='dynamic')
__table_args__ = ({"useexisting": True})
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
return dict
def __repr__(self):
return '<Role %r>' % self.name
class Reply(db.Model):
__tablename__ = 'reply'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
content = db.Column(db.String(140), nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
# 所属主贴
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
post = db.relationship('Post', backref=db.backref('posts'))
# 回复用户
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = db.relationship('User', backref=db.backref('replies'))
class BookingRequest(db.Model):
id = db.Column(db.Integer, primary_key=True)
booking_date = db.Column(db.Date)
booking_time = db.Column(db.Time)
details = db.Column(db.String(240))
status = db.Column(db.String(20))
booking_id = db.Column(db.Integer(), db.ForeignKey(Booking.id))
worker_id = db.Column(db.Integer(), db.ForeignKey(User.id))
booking = db.relationship(Booking, foreign_keys=[booking_id])
worker = db.relationship(User, foreign_keys=[worker_id])
def __str__(self):
return self.details
class Menu(db.Model):
'''
菜单
'''
__tablename__ = 'db_menu'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
index=True,
autoincrement=True)
menu_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
pid = db.Column(db.String(36), nullable=False, index=True, default='0')
title = db.Column(db.String(64), nullable=False, unique=True)
path = db.Column(db.String(255), nullable=False, unique=True)
icon = db.Column(db.String(255), nullable=False)
mark = db.Column(db.String(255), nullable=False, unique=True)
sort = db.Column(db.SmallInteger, index=True, default=1)
is_disabled = db.Column(db.Boolean, index=True, default=False)
interfaces = db.relationship('Interface', backref='menu')
__table_args__ = ({"useexisting": True})
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
return dict
def __repr__(self):
return '<Menu %r>' % self.title
class OAuth2AuthorizationCode(db.Model, OAuth2AuthorizationCodeMixin):
__tablename__ = 'oauth2_code'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(
db.Integer, db.ForeignKey('account.id', ondelete='CASCADE'))
user = db.relationship('User')
class Folder(db.Model):
'''
文件夹
'''
__tablename__ = 'db_folder'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
index=True,
autoincrement=True)
folder_id = db.Column(db.String(36),
index=True,
nullable=False,
unique=True)
admin_id = db.Column(db.String(36), index=True)
pid = db.Column(db.String(36), nullable=False, index=True, default='0')
name = db.Column(db.String(36), index=True, nullable=False)
is_sys = db.Column(db.Boolean, index=True, default=True) # True = 系统文件夹
create_time = db.Column(db.DateTime,
index=True,
default=datetime.datetime.now)
documents = db.relationship('Document', backref='folder')
__table_args__ = ({"useexisting": True})
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
if "create_time" in dict:
dict["create_time"] = dict["create_time"].strftime(
'%Y-%m-%d %H:%M:%S')
return dict
def __repr__(self):
return '<Folder %r>' % self.name
class TrusteeshipOrder(db.Model):
"""
The model of trusteeship orders
"""
id = db.Column(db.Integer,
autoincrement=True,
nullable=False,
primary_key=True,
unique=True)
ord_num = db.Column(db.String(30), nullable=False)
species = db.Column(db.String(50), nullable=False)
pet_name = db.Column(db.String(50), nullable=False)
age = db.Column(db.Integer, nullable=False)
weight = db.Column(db.Float, nullable=False)
expiration = db.Column(db.Integer, nullable=False)
sterilization = db.Column(db.Boolean, nullable=False)
naughty = db.Column(db.Boolean)
shy = db.Column(db.Boolean)
friendly = db.Column(db.Boolean)
comment = db.Column(db.Text)
price = db.Column(db.Float, nullable=False)
status = db.Column(db.Integer, nullable=False, default=0)
create_time = db.Column(db.DateTime, nullable=False)
open_time = db.Column(db.DateTime)
close_time = db.Column(db.DateTime)
agency_fee = db.Column(db.Float)
agency_id = db.Column(db.Integer,
db.ForeignKey('agency.id'),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
images = db.relationship("Image",
secondary=trust_order_image,
lazy='subquery',
backref=db.backref('image_in', lazy=True))
class ResetPassword(db.Model):
id = db.Column(db.Integer, primary_key=True)
password = db.Column(db.String(80))
user_id = db.Column(db.Integer(), db.ForeignKey(User.id))
user = db.relationship(User, foreign_keys=[user_id])
def __str__(self):
return self.username
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
content = db.Column(db.String(140), nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = db.relationship('User', backref=db.backref('posts'))
image = db.Column(db.String(10), default='/')
class Booking(db.Model):
id = db.Column(db.Integer, primary_key=True)
booking_date = db.Column(db.Date)
booking_time = db.Column(db.Time)
details = db.Column(db.String(240))
address = db.Column(db.String(200))
is_taken = db.Column(db.Boolean)
is_done = db.Column(db.Boolean)
is_cancel = db.Column(db.Boolean)
service_name = db.Column(db.Integer, db.ForeignKey(Service.name))
service = db.relationship(Service, backref='service')
customer_id = db.Column(db.Integer(), db.ForeignKey(User.id))
customer = db.relationship(User, foreign_keys=[customer_id])
worker_id = db.Column(db.Integer(), db.ForeignKey(User.id))
worker = db.relationship(User, foreign_keys=[worker_id])
def __str__(self):
return 'Need "{}" by "{} {}" on "{} {}"'.format(
self.service.name, self.customer.first_name,
self.customer.last_name, self.booking_date, self.booking_time)
class OAuth2Token(db.Model, OAuth2TokenMixin):
__tablename__ = 'oauth2_token'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(
db.Integer, db.ForeignKey('account.id', ondelete='CASCADE'))
user = db.relationship('User')
def is_refresh_token_expired(self):
expires_at = self.issued_at + self.expires_in * 2
return expires_at < time.time()
class ProjectModel(Base):
__tablename__ = 'projects'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
todos = db.relationship('TodoModel', lazy='dynamic')
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('UserModel')
def __init__(self, name, user_id=None):
self.name = name,
self.user_id = user_id
def json(self):
return {
'id': self.id,
'name': self.name,
'user_id': self.user_id,
'todos': [todo.json() for todo in self.todos.all()]
}
class Word(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
frequency = db.Column(db.Integer)
site_id = db.Column(db.Integer, db.ForeignKey('site.id'), nullable=False)
site = db.relationship('Site',
backref=db.backref('words',
lazy='dynamic',
cascade='all, delete'))
@property
def json(self):
return to_json(self, self.__class__)
class AuditLog(IdMixin, CreationTimeMixin, db.Model):
__tablename__ = 'audit_logs'
entity_id = db.Column(db.BigInteger)
entity_type = db.Column(db.String, nullable=False)
action = db.Column(db.String, nullable=False)
user_id = db.Column(db.BigInteger,
db.ForeignKey('base_users.id'),
nullable=True)
old_value = db.Column(db.String)
new_value = db.Column(db.String)
user = db.relationship('User', lazy=True)
class Image(db.Model):
"""
The model of images
"""
id = db.Column(db.Integer,
autoincrement=True,
nullable=False,
primary_key=True,
unique=True)
name = db.Column(db.String(50), nullable=False)
physical_name = db.Column(db.String(50), nullable=False)
url = db.Column(db.String(250), nullable=False)
upload_time = db.Column(db.DateTime, nullable=False)
agency_avator = db.relationship("Agency", backref='avator_of')
class UserCred(db.Model):
__tablename__ = 'cred'
user_id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(20), unique=True)
pw_hash = db.Column(db.String(180), unique=True)
info = db.relationship('UserInfo', uselist=False,
back_populates="cred") # NOT USE
def __init__(self, login, password):
self.login = login
self.pw_hash = bcrypt.generate_password_hash(password).decode('utf8')
def create_auth_token(self):
try:
return os.urandom(24).hex()
except Exception as e:
return e
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
username = db.Column(db.String(80), unique=True)
password = db.Column(db.String(80))
email = db.Column(db.String(120), unique=True)
address = db.Column(db.String(200))
barangay = db.Column(db.String(100))
phone_no = db.Column(db.String(30))
role = db.Column(db.String(20))
registration_id = db.Column(db.String(300))
is_verified = db.Column(db.Boolean)
services = db.relationship(Service,
secondary=user_services_table,
backref=db.backref('users'))
def __str__(self):
return '{} {}'.format(self.first_name, self.last_name)
class UserInfo(db.Model):
__tablename__ = 'info'
info_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
surname = db.Column(db.String(20))
age = db.Column(db.Integer)
user_id = db.Column(db.Integer, db.ForeignKey('cred.user_id')) # NOT USE
cred = db.relationship('UserCred', uselist=False,
back_populates="info") # NOT USE
def __init__(self, id, name=None, surname=None, age=None):
self.name = name
self.surname = surname
self.age = age
self.user_id = id
def update_fields(self, fields):
keys = ['name', 'surname', 'age']
for key in keys:
if fields.get(key) is not None:
setattr(self, key, fields[key])
class User(db.Model):
"""
The model of user and authorization information
"""
id = db.Column(
db.Integer,
autoincrement=True,
nullable=False,
primary_key=True,
unique=True
)
username = db.Column(db.String(20), nullable=False)
password_hash = db.Column(db.String(120), nullable=False)
phone = db.Column(db.String(15), nullable=False)
email = db.Column(db.String(50), nullable=False)
create_time = db.Column(db.DateTime, nullable=False)
own_agent_id = db.Column(
db.Integer,
db.ForeignKey("agency.id"),
nullable=True
)
comments = db.relationship("Comment", backref="author")
comments_order = db.relationship("TrusteeshipOrder", backref="consumer")
def hash_password(self, password):
"""
Save the hash password
:param password: origin password
"""
self.password_hash = custom_app_context.hash(str(password))
def verify_password(self, password):
"""
Verify the password
:param password: origin password
:return: bool
"""
return custom_app_context.verify(password, self.password_hash)
def generate_token(self, expiration=600):
"""
Generate a new token
:param expiration: how long it lasts
:return: the signature
"""
serializer = TimedJSONWebSignatureSerializer(SECRET_KEY, expiration)
return serializer.dumps({"id": self.id}).decode("utf-8")
@staticmethod
def verify_token(token):
"""
Verify the token
:param token: the given signature
:return: the user information or error message
"""
serializer = TimedJSONWebSignatureSerializer(SECRET_KEY)
try:
data = serializer.loads(bytes(token, encoding="utf-8"))
except SignatureExpired:
return None
except BadSignature:
return None
return User.query.get(data["id"])