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)