class Licence(db.Model): licence = db.Column(db.String(256), primary_key=True) name = db.Column(db.String(256)) url = db.Column(db.Text) text = db.Column(db.Text) publications = db.relationship('Publication', backref='licence', lazy=True)
class Target(db.Model, SoftDeleteMixin): __tablename__ = 'target' id = db.Column( UUID(as_uuid=True), default=uuid4, primary_key=True, ) last_message_id = db.Column( UUID(as_uuid=True), nullable=True, ) type = db.Column( db.String(25), nullable=False, ) messages = db.relationship('Message', ) __mapper_args__ = { 'polymorphic_identity': __tablename__, 'polymorphic_on': type, } def to_dict(self): return dict( id=self.id, last_message_id=self.last_message_id, members=[m.member_id for m in self.target_members], is_deleted=True if self.removed_at is not None else False, removed_at=self.removed_at, created_at=self.created_at, )
class Logic(db.Model): __tablename__ = 'logic' id = db.Column(db.Integer, primary_key=True) project_id = db.Column(db.Integer, db.ForeignKey('projects.id')) component_1_id = db.Column(db.Integer, db.ForeignKey('components.id')) component_2_id = db.Column(db.Integer, db.ForeignKey('components.id')) message_type = db.Column( db.Enum('BasicEvent', 'RequestEvent', 'Response', 'NewEvent', name='message_type')) __table_args__ = (UniqueConstraint("project_id", "component_1_id", "component_2_id", "message_type"), ) @classmethod def generate_fake(cls, project, component1, component2): from random import randint message_type = Logic.message_type.property.columns[0].type.enums[ randint(0, 1)] fake = Logic(project_id=project.id, component_1_id=component1.id, component_2_id=component2.id, message_type=message_type) db.session.add(fake) db.session.commit() return fake def __repr__(self): return '<Logic project:%d component.No1:%d component.No2:%d message type:%r>' % ( self.project_id, self.component_1_id, self.component_2_id, self.message_type)
class TargetMember(db.Model): __tablename__ = 'target_member' target_id = db.Column( UUID(as_uuid=True), db.ForeignKey('target.id'), primary_key=True, ) member_id = db.Column( UUID(as_uuid=True), db.ForeignKey('member.id'), primary_key=True, ) member = db.relationship( 'Member', foreign_keys=[member_id], ) target = db.relationship( 'Target', foreign_keys=[target_id], ) def init(self, member_id, target_id): self.member_id = member_id self.target_id = target_id def to_dict(self): return dict( member_id=self.member_id, target_id=self.target_id, )
class Tag(db.Model): __tablename__ = "tags" query_class = TagQuery id = db.Column(db.Integer, primary_key=True) slug = db.Column(db.Unicode(80), unique=True) posts = db.dynamic_loader(Post, secondary=post_tags, query_class=PostQuery) _name = db.Column("name", db.Unicode(80), unique=True) def __init__(self, *args, **kwargs): super(Tag, self).__init__(*args, **kwargs) def __str__(self): return self.name def _get_name(self): return self._name def _set_name(self, name): self._name = name.lower().strip() self.slug = slugify(name) name = db.synonym("_name", descriptor=property(_get_name, _set_name)) @cached_property def url(self): return url_for("frontend.tag", slug=self.slug) num_posts = db.column_property( db.select([db.func.count(post_tags.c.post_id)]).\ where(db.and_(post_tags.c.tag_id==id, Post.id==post_tags.c.post_id)).as_scalar())
class User(db.Model, fsqla.FsUserMixin): # __tablename__ = 'tb_sy_user' name = db.Column(db.String(100)) sex = db.Column(db.String(1)) age = db.Column(db.Integer) logs = db.relationship("AnalysesLog", backref=db.backref("user")) @staticmethod def data_table_fields() -> list: """ 数据表的字段列表 Returns: """ return ["id", "username", "s_name", "last_login_date"] def to_dict(self): return { "id": self.id, "s_name": self.name, "username": self.username, "last_login_date": self.last_login_at, "access": self.roles[0].name }
class Todo(db.Model): """data model""" __tablename__ = 'todo' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255), nullable=False) posted_on = db.Column(db.Date, default=datetime.utcnow) status = db.Column(db.Boolean(), default=False) def __init__(self, *args, **kwargs): super(Todo, self).__init__(*args, **kwargs) def __repr__(self): return "<Todo '%s'>" % self.title def store_to_db(self): """save to database""" db.session.add(self) db.session.commit() def delete_todo(self): """delete data""" db.session.delete(self) db.session.commit()
class Event(db.Model): __tablename__ = 'events' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(80), nullable=False) description = db.Column(db.String(80), nullable=False) date = db.Column(db.Date, nullable=False) time = db.Column(db.Time, nullable=False) type = db.Column(ChoiceType(EventType), nullable=False) category = db.Column(ChoiceType(CategoryType), nullable=False) location_id = db.Column(db.Integer, db.ForeignKey("locations.id")) location = db.relationship("Location", back_populates="events", lazy='joined') address = db.Column(db.String(80), nullable=False) seats = db.Column(db.Integer) enrollments = db.relationship("Enrollment", back_populates="event", lazy='joined') participants = db.relationship('Participant', secondary='enrollments', back_populates='events', lazy='joined') def __str__(self): return f'{self.title}'
class UserData(db.Model, CRUDMixin, TimeMixin): """ collection of user data, from query used as cache, data encrpted with aes """ id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True) data = db.Column(db.String()) name = db.Column(db.String()) user_id = db.Column(db.String, db.ForeignKey('user.id')) status = db.Column(db.String()) # client_id = StringField(default='client_') def to_json(self): return { 'data': self.data, 'name': self.name, 'created': self.created, 'status': self.status } def get_client(self): client = redis_store.get(user_data.client_id, None) return client def lock_save(self, pw): in_len = len(self.data) pad_size = 16 - (in_len % 16) self.data = self.data.ljust(in_len + pad_size, chr(pad_size)) if len(pw) < 16: pw += '0' * (16 - len(pw)) iv = binascii.a2b_hex('000102030405060708090a0b0c0d0e0f') obj = AES.new(pw, AES.MODE_CBC, iv) self.data = str(binascii.b2a_base64(obj.encrypt(self.data)))[2:-2] self.save()
class Permission(db.Model): __tablename__ = 'permissions' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), unique=True) roles = db.relationship( 'Role', secondary=roles_permissions, backref=db.backref('permissions', lazy='dynamic'))
class ConversationMember(db.Model): id = db.Column(db.UUID(as_uuid=True),default=uuid.uuid4, primary_key=True) conversation_id = db.Column(db.UUID, db.ForeignKey('conversation.id')) member = db.Column(db.String, db.ForeignKey('user.id')) avatar_URL = db.Cloumn(db.String) status = db.Cloumn(db.String) created = DateTimeField(default=datetime.datetime.now) last_open =
class UserContact(db.Model): user = db.Column(db.String, db.ForeignKey('user.id')) contact = db.Column(db.String, db.ForeignKey('user.id')) conversation = db.Column(db.UUID, db.ForeignKey('conversation.id')) unread_messges_count = IntField() last_open = DateTimeField() avatar = StringField() title = StringField()
class UserAbility(db.Model, UserMixin): __tablename__ = 'user_ability' id = db.Column(db.Integer, primary_key=True) aid = db.Column(db.Integer) uid = db.Column(db.Integer, db.ForeignKey('users.id')) __table_args__ = ( UniqueConstraint("aid", "uid"), )
class DynamicModel(db.Model): id = db.Column(db.Integer, primary_key=True) schema = db.Column(db.String(100), nullable=False) entry_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) json_blob = db.Column(db.JSON, nullable=False) def __repr__(self): return f"DynamicModel('{self.id}','{self.schema}', '{self.entry_date}', '{self.json_blob}')"
class Category(db.Model): """ actually our wiki, containing concepts and tags, linked to by markdown """ category = db.Column(db.String(64), primary_key=True) # Local Authority, Planning Authority, etc text = db.Column(db.Text) publications = db.relationship('Publication', backref='category', lazy=True) organisations = db.relationship('Organisation', backref='category', lazy=True)
class Cache(db.Model): id = db.Column(UUID(as_uuid=True), default=_generate_uuid, primary_key=True, nullable=False) url = db.Column(db.String, nullable=False) data = db.Column(JSONB, nullable=False) created_date = db.Column(db.Date(), default=datetime.today, nullable=False)
class Category(db.Model): __tablename__ = 'categories' id = db.Column(db.Integer, primary_key=True) code = db.Column(db.String(15), unique=True, nullable=False) title = db.Column(db.String(80), unique=True, nullable=False) meals = db.relationship("Meal", back_populates="category", lazy='joined') def __str__(self): return f'{self.title}'
class Follow(db.Model): __tablename__ = 'follows' follower_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True) followed_id = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True) timestamp = db.Column(db.DateTime, default=datetime.utcnow)
class TopProject(db.Model): __tablename__ = 'top_projects' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Unicode(length=100, convert_unicode=True), nullable=False) description = db.Column(db.Unicode(length=5000, convert_unicode=True)) def __repr__(self): return '<Top Project %r>' % self.name
class Star(db.Model): __tablename__ = 'stars' id = db.Column(db.Integer, primary_key=True) component_id = db.Column(db.Integer, db.ForeignKey('components.id'), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) amount = db.Column(db.Integer, default=0) __table_args__ = (UniqueConstraint("component_id", "user_id"), )
class Location(db.Model): __tablename__ = 'locations' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(80), unique=True, nullable=False) code = db.Column(db.String(8), unique=True, nullable=False) events = db.relationship("Event", back_populates="location", lazy='joined') def __str__(self): return f'{self.title}'
class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) hashed_password = db.Column(db.String(512), unique=True, nullable=False) def __repr__(self): return self.username def hash_password(self, password): return generate_password_hash(password)
class StoreActivityType(db.Model): ''' 系统用户 ''' __tablename__ = 'store_activity_type' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100)) def __unicode__(self): return '%s' % str(self.id)
class Corpus(db.Model): """Data model for a corpus.""" __tablename__ = 'corpus' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255), nullable=False) status = db.Column(db.String(32), index=False, nullable=False) def __repr__(self): return '<Corpus {}>'.format(self.name)
class DynamicModel(db.Model): id = db.Column(db.Integer, primary_key=True) uuid = db.Column(db.Integer, default=random_integer, unique=True, nullable=False) # uuid = db.Column(UUID(as_uuid=True), unique=True, nullable=False) schema = db.Column(db.String(100), nullable=False) status = db.Column(db.String(15), nullable=False, default='draft') json_blob = db.Column(db.JSON, nullable=False) def __repr__(self): return f"DynamicModel('{self.id}', '{self.uuid}', '{self.schema}', '{self.status}', '{self.json_blob}')"
class Card(db.Model): ''' 系统用户 ''' __tablename__ = 'cards' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100)) desc = db.Column(db.String(500)) price = db.Column(db.Integer, default=199) def __unicode__(self): return '%s' % str(self.id)
class UserPointRecord(db.Model): ''' 系统用户 ''' __tablename__ = 'user_point_records' id = db.Column(db.Integer, primary_key=True) point = db.Column(db.Integer) desc = db.Column(db.Integer) create_time = db.Column(db.DateTime, default=db.func.current_timestamp()) def __unicode__(self): return '%s' % str(self.id)
class CorpusResult(db.Model): """Data model for result returned from Watson NLU service.""" __tablename___ = 'corpus_result' id = db.Column(db.Integer, primary_key=True) corpus_id = db.Column(db.Integer, db.ForeignKey("corpus.id"), nullable=False) name = db.Column(db.String(255), nullable=False) data = db.Column(db.BINARY, nullable=True) def __repr__(self): return '<Corpus Result {}>'.format(self.id)
class UserInfo(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String, unique=True, nullable=False) display_name = db.Column(db.String) password = db.Column(db.String, nullable=False) def update_password(self, new_password): self.password = generate_password_hash(new_password) def has_password(self, passwd): return check_password_hash(self.password, passwd)
class Post(db.Model, CRUDMixin, TimeMixin): id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True) author_id = db.Column(db.String, db.ForeignKey('user.id')) type = db.Column(db.String) # lost or found tags = db.Column(db.ARRAY(db.String, dimensions=1)) title = db.Column(db.String) category = db.Column(db.String) content = db.Column(db.String) img_URLs = db.Column(postgresql.ARRAY(db.String, dimensions=1)) site = db.Column(db.String) hit = db.Column(db.Integer, default=0) author = db.relationship('User', backref=db.backref( 'posts', lazy=True))