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 User(UserMixin, db.Model, TimestampMixin):
"""
User model.
`account_type`: `basic` and `premium`, also `admin`, but not sure about that yet. It"s `basic` by default
`status`: by default inactive, becomes active after email confirmation
"""
__tablename__ = "users"
id = db.Column(UUID(as_uuid=True), primary_key=True, nullable=False, default=uuid4)
email = db.Column(db.String(255), nullable=False)
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255), nullable=False)
password = db.Column(PasswordType(schemes=["bcrypt"]), nullable=False)
is_active = db.Column(db.Boolean(), nullable=False, server_default="1")
confirmed = db.Column(db.Boolean(), nullable=False, server_default="0")
email_confirmed_at = db.Column(db.DateTime())
roles = db.relationship("Role", secondary="user_roles")
__table_args__ = (
UniqueConstraint("email", name="uq_users_email"),
)
def __init__(self, *args, **kwargs):
super(User, self).__init__(*args, **kwargs)
@staticmethod
def auth(email, password):
user = User.query.filter_by(email=email).first()
if user and user.password == password:
return user
return None
def __repr__(self):
return f"User(id={self.id}, email={self.email}, account_type={self.account_type}, status={self.status})"
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 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 Address(db.Model):
'''
地址管理
'''
__tablename__ = 'addresses'
id = db.Column(db.Integer, primary_key=True)
state = db.Column(db.String(100))
city = db.Column(db.String(100))
street = db.Column(db.String(255))
telephone1 = db.Column(db.String(100))
telephone2 = db.Column(db.String(100))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
def __unicode__(self):
return '%s' % str(self.id)
@property
def fields(self):
return ['state', 'city', 'street', 'telephone1', 'telephone2']
def to_json(self):
result = {f: getattr(self, f) for f in self.fields}
result.update({'id': str(self.id)})
return result
class CompulsoryPurchaseOrderInvestigation(db.Model, OrderedMixin):
compulsory_purchase_order_investigation = db.Column(db.Integer(),
primary_key=True,
nullable=False)
status = db.Column(db.String())
inspector_report_url = db.Column(db.String())
decision_url = db.Column(db.String())
start_date = db.Column(db.Date())
end_date = db.Column(db.Date())
compulsory_purchase_order_id = db.Column(
db.String,
db.ForeignKey('compulsory_purchase_order.compulsory_purchase_order'))
compulsory_purchase_order = db.relationship(
'CompulsoryPurchaseOrder', back_populates='investigations')
def is_final_state(self):
return self.status in final_states
def __hash__(self):
return hash(self.compulsory_purchase_order_investigation)
def __eq__(self, other):
return self.compulsory_purchase_order_investigation == other.compulsory_purchase_order_investigation
class StoreActivity(db.Model):
'''
系统用户
'''
__tablename__ = 'store_activities'
id = db.Column(db.Integer, primary_key=True)
type_id = db.Column(db.Integer)
name = db.Column(db.String(100))
poster_img = db.Column(db.String(255))
desc = db.Column(db.Text)
every_count = db.Column(db.Integer)
max_count = db.Column(db.Integer)
store_id = db.Column(db.String(255))
is_hot = db.Column(db.Boolean, default=True)
create_time = db.Column(db.DateTime, default=db.func.current_timestamp())
is_deleted = db.Column(db.Boolean, default=False)
deleted_time = db.Column(db.DateTime)
def __unicode__(self):
return '%s' % str(self.id)
def mark_deleted(self):
if self.is_deleted:
return
self.is_deleted = True
self.deleted_date = datetime.datetime.utcnow()
db.session.commit()
class Feature(db.Model):
feature = db.Column(db.String(256), primary_key=True)
item = db.Column(db.String(256))
data = db.Column(JSONB)
geometry = db.Column(Geometry(srid=4326))
name = db.Column(db.Text)
publication = db.Column(db.String(64))
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 Component(db.Model):
__tablename__ = 'components'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
deploy_version = db.Column(db.String(16))
private = db.Column(db.Boolean, default=True)
mean = db.Column(db.Float(precision=1), default=0)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def generate_token(self):
s = Serializer(current_app.config['SECRET_KEY'])
return s.dumps({'id': self.id})
@classmethod
def verify_token(cls, token):
"""
:raises BadSignature
:param token:
:return: component object that match token
"""
s = Serializer(current_app.config['SECRET_KEY'])
data = s.loads(token)
component = cls.query.get(data['id'])
return component
def component_files(self):
return [
filename for filename in os.listdir(
current_app.config['COMPONENT_UPLOAD_FOLDER'])
if filename.startswith(str(self.id))
]
def to_json(self):
return {
"pid": self.id,
"name": self.name,
"deploy_version": self.deploy_version,
"private": self.private
}
@classmethod
def generate_fake(cls, user):
from shutil import copyfile
from random import randint
fake = Component(name='Fake Component',
deploy_version=randint(0, 10),
owner_id=user.id)
db.session.add(fake)
db.session.commit()
"""apply deploy version again"""
copyfile(
current_app.config['FAKE_UPLOAD'],
os.path.join(current_app.config['UPLOAD_FOLDER'], 'components',
'%s.%s' % (str(fake.id), 'jar')))
return fake
def __repr__(self):
return '<Component %r>' % self.name
class User(UserMixin, db.Model):
"""User Model """
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
firstname = db.Column(db.String(100), nullable=False)
lastname = db.Column(db.String(100), nullable=False)
password = db.Column(db.String(250), unique=True, nullable=False)
posts = db.relationship('Post', backref=db.backref('posts', lazy=True))
followed = db.relationship('Follow',
foreign_keys=[Follow.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
created_on = db.Column(db.DateTime, default=datetime.utcnow)
def set_password(self, password):
"""Create User Password """
self.password = generate_password_hash(password, method='sha256')
def check_password(self, password):
"""Check Hashed Password"""
return check_password_hash(self.password, password)
def is_following(self, user):
if user.id is None:
return False
return self.followed.filter_by(followed_id=user.id).first() is not None
def is_followed_by(self, user):
if user.id is None:
return False
return self.followers.filter_by(
follower_id=user.id).first() is not None
def follow(self, user):
if not self.is_following(user):
f = Follow(follower=self, followed=user)
db.session.add(f)
def unfollow(self, user):
f = self.followed.filter_by(followed_id=user.id).first()
if f:
f = self.followed.filter_by(followed_id=user.id).first()
db.session.delete(f)
return True
def __repr__(self):
return '<User {}>'.format(self.username)
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 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 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 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 Book(db.Model):
__tablename__ = 'book'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
title = db.Column(db.String(64), nullable=True)
author = db.Column(db.String(256), nullable=True)
page_number = db.Column(db.Integer, nullable=True)
book_url = db.Column(db.String(256), nullable=False)
thumbnaiUrl = db.Column(db.String(256), nullable=True)
class Video(db.Model):
__tablename__ = 'video'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
title = db.Column(db.String(64), nullable=True)
text = db.Column(db.String(512), nullable=True)
video_url = db.Column(db.String(256), nullable=False)
thumbnaiUrl = db.Column(db.String(256), nullable=True)
class Device(db.Model):
__tablename__ = 'device'
id = db.Column(db.Integer, primary_key=True)
device_id = db.Column(db.Integer, unique=True, nullable=True)
versionName = db.Column(db.String(256), unique=True, nullable=True)
applicationName = db.Column(db.String(256), unique=False, nullable=True)
deviceName = db.Column(db.String(256), unique=False, nullable=True)
systemName = db.Column(db.String(256), unique=False, nullable=True)
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 Sound(db.Model):
__tablename__ = 'sound'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
time = db.Column(db.TIME, nullable=True)
singer = db.Column(db.String(64), nullable=True)
sound_url = db.Column(db.String(256), nullable=False)
name = db.Column(db.String(128), nullable=True)
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 User(db.Model):
'''
系统用户
'''
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
weixin_openid = db.Column(db.String(100))
mobile = db.Column(db.String(100))
password = db.Column(db.String(255))
nickname = db.Column(db.String(255))
gender = db.Column(db.INT, default=0)
create_time = db.Column(db.DateTime, default=db.func.current_timestamp())
is_deleted = db.Column(db.Boolean, default=False)
deleted_time = db.Column(db.DateTime)
def __unicode__(self):
return '%s' % str(self.id)
def generate_password(self, password):
self.password = bcrypt.generate_password_hash(password).decode('utf-8')
print(self._password)
def check_password(self, password):
if self.password is None:
return False
return bcrypt.check_password_hash(self.password, password)
@classmethod
def create(cls, weixin_openid, nickname):
user = User(weixin_openid=weixin_openid)
db.session.add(user)
db.session.commit()
return user
@classmethod
def authenticate(cls, email=None, password=None):
if email:
user = cls.query.filter_by(email=email).first()
else:
user = None
if user:
authenticated = user.check_password(password)
else:
authenticated = False
return user, authenticated
def mark_deleted(self):
if self.is_deleted:
return
self.is_deleted = True
self.deleted_date = datetime.datetime.utcnow()
db.session.commit()
class User(db.Model):
"""定义数据模型"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
def __init__(self, username, email):
self.username = username
self.email = email
def __repr__(self):
return '<User %r>' % self.usernames
class Applicant(db.Model):
__tablename__ = 'applicants'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
phone = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(80), nullable=False)
status = db.Column(ChoiceType(ApplicantStatus), nullable=False)
group_id = db.Column(db.Integer, db.ForeignKey("groups.id"))
group = db.relationship("Group",
back_populates="applicants",
lazy='joined')
def __str__(self):
return f'{self.name}'
class PlanningAuthority(db.Model):
id = db.Column(db.String(64), primary_key=True)
ons_code = db.Column(db.String(9))
name = db.Column(db.String(256))
website = db.Column(db.String())
local_plans = db.relationship(
'LocalPlan',
secondary=planning_authority_plan,
lazy='dynamic',
back_populates='planning_authorities',
)
def sorted_plans(self, reverse=False, deleted=False):
plans = self.local_plans.filter(LocalPlan.deleted == deleted).all()
return sorted(plans, reverse=reverse)
def get_earliest_plan_start_year(self):
try:
first = next(p for p in self.sorted_plans()
if p.plan_start_year is not None)
if first is not None:
return first.plan_start_year.year
else:
return None
except StopIteration:
return None
def get_latest_plan_end_year(self):
try:
first = next(p for p in self.sorted_plans(reverse=True)
if p.plan_end_year is not None)
if first is not None:
return first.plan_end_year.year
else:
return None
except StopIteration:
return None
def code(self):
return self.id.split(':')[-1]
def to_dict(self):
data = {
'id': self.id,
'name': self.name,
'ons_code': self.ons_code,
'plans': [plan.to_dict(self.id) for plan in self.local_plans]
}
return data
class Room(db.Model, CRUDMixin):
__tablename__ = 'room'
id = db.Column(db.UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
group = db.Column(db.String())
campus = db.Column(db.String())
building = db.Column(db.String)
floor = db.Column(db.Integer)
no = db.Column(db.Integer)
capacity = db.Column(db.Integer)
name = db.Column(db.String(80), nullable=False)
detail = db.Column(db.String(80), nullable=False)
available = db.Column(db.Boolean, default=True)
orders = db.relationship('Order',
lazy='select',
backref=db.backref('room', lazy=True))
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
email = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def __str__(self):
return f'{self.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 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 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'))
