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 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 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 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 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 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 Comment(db.Model):
"""
The model of user comments
"""
id = db.Column(db.Integer,
autoincrement=True,
nullable=False,
primary_key=True,
unique=True)
content = db.Column(db.Text, nullable=False)
rank = db.Column(db.Integer, nullable=False)
create_time = db.Column(db.DateTime, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
agency_id = db.Column(db.Integer,
db.ForeignKey("agency.id"),
nullable=False)
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 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))
email = db.Column(db.String(255))
sex = db.Column(db.SmallInteger, default=1)
avatarUrl = db.Column(db.String(255))
is_disabled = db.Column(db.Boolean, index=True, default=False)
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)
role_id = db.Column(db.String(36),
db.ForeignKey('db_role.role_id', ondelete='CASCADE'))
__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 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 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 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 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 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 Settings(Base):
__tablename__ = 'settings'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False,
unique=True)
synced_calendars = db.Column(db.JSON)
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 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 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 Action(db.Model, ModelMethods):
_table_name = 'action'
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer, db.ForeignKey("post.id"))
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
time = db.Column(db.DateTime())
def __init__(self, post_id, user_id, like_time=None):
self.post_id = post_id
self.user_id = user_id
if like_time:
self.time = like_time
else:
self.time = datetime.now()
def __repr__(self):
return "Like: {} {} {}".format(self.post_id, self.user_id, self.time)
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 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 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 Sync(Base):
__tablename__ = 'sync'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
status = db.Column(db.String(256))
start = db.Column(db.DateTime,
comment='A timestamp of when the sync started')
end = db.Column(db.DateTime,
comment='A timestamp of when the sync started')
message = db.Column(db.Text)
tasks = relationship("SyncTask", back_populates="sync")
user = relationship("User")
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 Counter(db.Model):
"""
The model of counter
"""
id = db.Column(db.Integer,
autoincrement=True,
nullable=False,
primary_key=True,
unique=True)
date_time = db.Column(db.DateTime, nullable=False)
agency_id = db.Column(db.Integer,
db.ForeignKey("agency.id"),
nullable=False)
class UserDatabase(Base):
__tablename__ = 'user_databases'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
drivername = db.Column(db.String(128))
username = db.Column(db.String(128))
password = db.Column(db.String(128))
host = db.Column(db.String(256))
port = db.Column(db.Integer)
database = db.Column(db.String(128))
query = db.Column(db.String(256))
user = relationship("User", back_populates="databases")
def get_url(self):
data = dump_json(self)
return get_db_url(loads(data))
class Entity(db.Model):
__metaclass__ = ABCMeta
__tablename__ = 'entity'
id = db.Column(db.Integer,
primary_key=True,
name="entity_id",
nullable=False)
type = db.Column(db.Enum(EntityType), name="entity_type", nullable=False)
city_id = db.Column(db.Integer,
db.ForeignKey("city.city_id"),
name="entity_city_id",
nullable=False)
city = relationship("City")
reviews = relationship("Review",
cascade="all, delete-orphan",
single_parent=True)
__mapper_args__ = {
'polymorphic_identity': EntityType.entity,
'polymorphic_on': type
}
@abstractmethod
def get_name(self, locale):
raise NotImplementedError("Must override method get_name")
@abstractmethod
def get_image(self):
raise NotImplementedError("Must override method get_image")
def to_entity_json(self, locale):
return {
'id': self.id,
'type': self.type.name,
'name': self.get_name(locale),
'image': self.get_image()
}
def to_json(self, locale):
return self.to_entity_json(locale)
def avg_rating(self):
if len(self.reviews) < 1:
return 0
return round(mean(map(lambda r: r.rating, self.reviews)), 2)
