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))
