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 LoginLock(db.Model):
'''
登录锁定
'''
__tablename__ = 'db_login_lock'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
index=True,
autoincrement=True)
lock_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
user_id = db.Column(db.String(36), index=True, nullable=False)
flag = db.Column(db.Boolean, index=True, default=False) # 是否锁定
number = db.Column(db.Integer, primary_key=True, default=0)
ip = db.Column(db.String(36), index=True)
lock_time = db.Column(db.DateTime)
__table_args__ = ({"useexisting": True})
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
if "lock_time" in dict:
dict["lock_time"] = dict["lock_time"].strftime('%Y-%m-%d %H:%M:%S')
return dict
def __repr__(self):
return '<LoginLock %r>' % self.lock_id
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 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 SyncTask(Base):
__tablename__ = 'sync_task'
id = db.Column(db.Integer, primary_key=True)
sync_id = db.Column(db.Integer, db.ForeignKey('sync.id'), nullable=False)
class_name = db.Column(db.String(256))
commit_id = db.Column(
db.String(256),
comment=
'This is a unique ID that represents a database commit. In the case of calendar sync, the commits are done on a cal by cal basis and therefore the commit ID should be the Calendar ID'
)
status = db.Column(db.String(256))
message = db.Column(db.Text)
errors = db.Column(db.Text)
pull_start = db.Column(
db.DateTime,
comment='A timestamp of when pulling data for a commit started')
pull_end = db.Column(
db.DateTime,
comment='A timestamp of when pulling data for a commit ended')
store_start = db.Column(
db.DateTime,
comment='A timestamp of storing data for a commit started')
store_end = db.Column(
db.DateTime, comment='A timestamp of storing data for a commit ended')
sync = relationship("Sync", back_populates="tasks")
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(20), nullable=False)
password = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(40))
tele = db.Column(db.String(11), default=11111111111)
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)
parent_id = 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)
sort = db.Column(db.SmallInteger, index=True, default=1)
type = db.Column(db.SmallInteger, index=True, default=1)
isLock = db.Column(db.Boolean, index=True, default=True)
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 Category(db.Model):
__tablename__ = "category"
id = db.Column(
db.Integer,
primary_key=True,
name="category_id",
nullable=False
)
label = db.Column(
db.String(30),
name="category_label",
nullable=False
)
name_id = db.Column(
db.String(36),
db.ForeignKey("locale_string.string_id"),
name="category_name_id",
nullable=False
)
name = relationship(
LocaleString,
foreign_keys=[name_id],
uselist=True,
single_parent=True,
cascade="all, delete-orphan",
collection_class=attribute_mapped_collection('locale')
)
def to_json(self, locale):
return {
'id': self.id,
'name': self.name.get(locale),
'label': self.label
}
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 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 CalendarUserAlias(Base):
__tablename__ = 'calendar_user_alias'
__bind_key__ = 'user_db'
alias = db.Column(db.String(200), primary_key=True)
calendar_user_id = db.Column(db.String(100),
db.ForeignKey('calendar_user.id'))
calendar_user = relationship("CalendarUser",
back_populates="user_aliasses")
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 Admin(db.Model):
'''
管理员
'''
__tablename__ = 'db_admin'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
index=True,
autoincrement=True)
admin_id = db.Column(db.String(36),
index=True,
nullable=False,
unique=True)
username = db.Column(db.String(64),
index=True,
nullable=False,
unique=True)
password = db.Column(db.String(32), nullable=False)
nickname = db.Column(db.String(64))
sex = db.Column(db.SmallInteger, default=1)
avatarUrl = db.Column(db.String(255))
isLock = db.Column(db.Boolean, index=True, default=True)
role_id = db.Column(db.Integer, db.ForeignKey('db_role.id'))
create_time = db.Column(db.DateTime,
index=True,
default=datetime.datetime.now)
update_time = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
__table_args__ = ({"useexisting": True})
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return unicode(self.admin_id)
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
if "update_time" in dict:
dict["update_time"] = dict["update_time"].strftime(
'%Y-%m-%d %H:%M:%S')
if "create_time" in dict:
dict["create_time"] = dict["create_time"].strftime(
'%Y-%m-%d %H:%M:%S')
return dict
def __repr__(self):
return '<admin %r>' % self.username
class UserMetabase(Base):
__tablename__ = 'user_metabase'
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False,
primary_key=True)
email = db.Column(db.String(128))
password = db.Column(db.String(128))
user = relationship("User", back_populates="metabase")
class Place(Object):
__tablename__ = "place"
id = db.Column(db.Integer,
db.ForeignKey("object.object_id"),
primary_key=True,
name="object_id",
nullable=False)
name_id = db.Column(db.String(36),
db.ForeignKey("locale_string.string_id"),
name="place_name_id",
nullable=False)
name = relationship(LocaleString,
foreign_keys=[name_id],
uselist=True,
single_parent=True,
cascade="all, delete-orphan",
collection_class=attribute_mapped_collection('locale'))
address_id = db.Column(db.String(36),
db.ForeignKey("locale_string.string_id"),
name="place_address_id",
nullable=False)
address = relationship(
LocaleString,
foreign_keys=[address_id],
uselist=True,
single_parent=True,
cascade="all, delete-orphan",
collection_class=attribute_mapped_collection('locale'))
geolocation_id = db.Column(
db.Integer,
db.ForeignKey("geolocation.geolocation_id"),
name="place_geolocation_id",
nullable=False,
)
geolocation = relationship("Geolocation",
cascade="all, delete-orphan",
single_parent=True)
routes = relationship("RoutePlaceInfo",
cascade="all, delete-orphan",
single_parent=True)
__mapper_args__ = {'polymorphic_identity': EntityType.place}
def get_name(self, locale):
return self.name.get(locale)
def to_json(self, locale):
object_json = super().to_json(locale)
place_json = {
'address': self.address.get(locale),
'geolocation': self.geolocation,
'description': self.description.get(locale),
'routes': list(map(lambda r: r.route_id, self.routes)),
}
return {**object_json, **place_json}
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 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 CalendarEventAttendees(Base):
__tablename__ = 'calendar_event_attendee'
__bind_key__ = 'user_db'
event_id = db.Column(db.String(500),
db.ForeignKey('calendar_event.event_id'),
primary_key=True)
invited_email = db.Column(db.String(200), primary_key=True)
# The ID of the user that was invited, regardless of which email alias was used for the invite
calendar_user_id = db.Column(db.String(100),
db.ForeignKey('calendar_user.id'))
# Get timezone from event if possibe.
timezone = db.Column(db.String(200))
# TODO As long as this isn't available, lets assume 9-5
working_hours_start_time = db.Column(db.TIME)
working_hours_end_time = db.Column(db.TIME)
# The timezone for the attendee when the event was organized
timezone_organized = db.Column(db.String(200))
display_name = db.Column(db.String(200))
response_status = db.Column(db.String(20))
is_organizer = db.Column(db.BOOLEAN)
is_optional = db.Column(db.BOOLEAN)
comment = db.Column(db.String(5000))
# Don't backpopulate the calendaruser as it doesn't seem useful and there will be too many entitities
calendar_user = relationship("CalendarUser")
calendar_event = relationship("CalendarEvents",
back_populates="calendar_event_attendees")
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 Review(db.Model):
__tablename__ = "review"
user_id = db.Column(db.Integer,
db.ForeignKey("user.user_id", ondelete="cascade"),
primary_key=True,
name="user_id",
nullable=False)
user = relationship("User")
entity_id = db.Column(db.Integer,
db.ForeignKey("entity.entity_id",
ondelete="cascade"),
primary_key=True,
name="entity_id",
nullable=False)
entity = relationship("Entity")
rating = db.Column(db.SMALLINT, name="review_rating", nullable=False)
time = db.Column(db.DateTime,
name="review_last_modified_time",
default=datetime.datetime.utcnow,
nullable=False)
text = db.Column(db.Text, name="review_text", nullable=True)
locale = db.Column(db.String(2), name="review_locale", nullable=True)
def to_json(self, locale):
return {
'user': self.user,
'entity': self.entity_id,
'time': str(self.time),
'rating': self.rating,
'text': str(self.text) if self.text is not None else None,
'locale': self.locale
}
class Post(db.Model, ModelMethods):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(512), nullable=False)
content = db.Column(db.Text(), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
time = db.Column(db.DateTime())
def __init__(self, title, content, user_id, time=None):
self.title = title
self.content = content
self.user_id = user_id
if time is None:
self.time = datetime.now()
else:
self.time = time
@classmethod
def get_user_liked(cls, post_id):
sql = text(
'select user.name from action join user on action.user_id = user.id where action.post_id = :post_id'
)
result = db.engine.execute(sql, post_id=post_id)
names = []
for row in result:
names.append(row[0])
return names
def __repr__(self):
return "Post: {} {} {} {}".format(self.title, self.content,
self.user_id, self.time)
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 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 TokenList(db.Model):
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(500), unique=True)
user_id = db.Column(db.Integer, unique=True)
def __init__(self, token, id):
self.token = token
self.user_id = id
class Interface(db.Model):
'''
接口
'''
__tablename__ = 'db_interface'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
index=True,
autoincrement=True)
interface_id = db.Column(db.String(36),
index=True,
nullable=False,
unique=True)
name = db.Column(db.String(64), index=True, nullable=False, unique=True)
path = db.Column(db.String(255), nullable=False, unique=True)
method = db.Column(db.String(36), nullable=False)
description = db.Column(db.String(255), nullable=False)
mark = db.Column(db.String(255), nullable=False, unique=True)
is_disabled = db.Column(db.Boolean, index=True, default=False)
not_allow = db.Column(db.Boolean, index=True, default=True)
menu_id = db.Column(db.String(36),
db.ForeignKey('db_menu.menu_id', ondelete='CASCADE'))
__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 '<Interface %r>' % self.name
class City(db.Model):
__tablename__ = "city"
id = db.Column(db.Integer,
primary_key=True,
name="city_id",
nullable=False)
name_id = db.Column(db.String(36),
db.ForeignKey("locale_string.string_id"),
name="city_name_id",
nullable=False)
name = relationship(LocaleString,
foreign_keys=[name_id],
uselist=True,
single_parent=True,
cascade="all, delete-orphan",
collection_class=attribute_mapped_collection('locale'))
image_link = db.Column(db.String(250),
name="city_image_link",
nullable=False)
description_id = db.Column(db.String(36),
db.ForeignKey("locale_string.string_id"),
name="city_description_id",
nullable=False)
description = relationship(
LocaleString,
foreign_keys=[description_id],
uselist=True,
single_parent=True,
cascade="all, delete-orphan",
collection_class=attribute_mapped_collection('locale'))
def to_attribute_json(self, locale):
return {
'id': self.id,
'name': self.name.get(locale),
}
def to_json(self, locale):
return {
'id': self.id,
'name': self.name.get(locale),
'description': self.description.get(locale),
'image_link': self.image_link,
}
class CalendarEvents(Base):
__tablename__ = 'calendar_event'
__bind_key__ = 'user_db'
# Should be the ID from Google
event_id = db.Column(db.String(500), primary_key=True)
created_at = db.Column(db.TIMESTAMP)
updated_at = db.Column(db.TIMESTAMP)
organizer_email = db.Column(db.String(200))
creator_email = db.Column(db.String(200))
# The status of the event. Can be cancelled.
status = db.Column(db.String(200))
# Add recurrance ID
is_recurring = db.Column(db.BOOLEAN)
recurrence_id = db.Column(db.String(200))
title = db.Column(db.String(500))
location = db.Column(db.String(500))
start_time = db.Column(db.TIMESTAMP)
end_time = db.Column(db.TIMESTAMP)
description = db.Column(db.Text(collation='utf8mb4_unicode_ci'))
calendar_event_attendees = relationship("CalendarEventAttendees",
back_populates="calendar_event")
class Route(db.Model):
'''
路由
'''
__tablename__ = 'db_route'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
index=True,
autoincrement=True)
route_id = db.Column(db.String(36),
index=True,
nullable=False,
unique=True)
pid = db.Column(db.String(36), nullable=False, index=True, default='0')
name = db.Column(db.String(64), index=True, nullable=False, unique=True)
title = db.Column(db.String(255), nullable=False)
path = db.Column(db.String(255), nullable=False, unique=True)
component = db.Column(db.String(255), nullable=False)
componentPath = db.Column(db.String(255), nullable=False)
cache = db.Column(db.Boolean, index=True, default=True)
is_disabled = db.Column(db.Boolean, index=True, default=False)
__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 '<Route %r>' % self.name
class User(UserMixin, db.Model, ModelMethods):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True)
name = db.Column(db.String(80))
phone = db.Column(db.String(40))
job = db.Column(db.String(40))
role = db.Column(db.Boolean) # True: Facebook user; False: Google user
def __init__(self, email, role):
self.email = email
self.role = role
def get_id(self):
return self.id
def __repr__(self):
return "User: {} {}".format(self.email, self.role)
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)
