class Employee(Base):
__tablename__ = 'employee'
id = Column(Integer, primary_key=True, autoincrement=True)
gender = Column(Enum('男', '女'))
name = Column(String(32), index=True)
nation = Column(String(32))
nativePlace = Column(String(32))
birthday = Column(Date())
idCard = Column(String(18), unique=True)
email = Column(String(32))
wedlock = Column(Enum('已婚', '未婚', '离异'))
phone = Column(String(11))
workAge = Column(Float)
tipTopDegree = Column(Enum('博士', '硕士', '本科', '大专', '高中', '初中', '小学', '其他'))
school = Column(String(32))
specialty = Column(String(32))
workState = Column(Enum('在职', '离职'))
type = Column(Enum('正式员工', '试用员工', '实习员工'))
departmentId = Column(Integer, ForeignKey('department.id'))
jobLevelId = Column(Integer, ForeignKey('job_level.id'))
workId = Column(String(20))
address = Column(String(64))
contractBeginDate = Column(Date())
contractEndDate = Column(Date())
lastCompany = Column(String(32))
joinDate = Column(Date())
account = db.relationship('User', uselist=False, backref="holder_info")
transfer_record = db.relationship('EmployeeTransfer',
backref='employee_info',
lazy=True)
training_record = db.relationship('EmployeeTrainingRecord',
backref='employee_info',
lazy=True)
class NewSubmission(db.Model, Base):
__tablename__ = 'new_submission'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
editor_in_chief_id = db.Column(db.Integer, db.ForeignKey('users.id'))
associate_editor_id = db.Column(db.Integer, db.ForeignKey('users.id'))
type_id = db.Column(db.Integer, db.ForeignKey('article_type.id'))
title = db.Column(db.String(256), nullable=False)
abstract = db.Column(db.Text)
keywords = db.Column(db.Text)
# classification_id TODO: 此键表还未建
comments = db.Column(db.Text)
current_status = db.Column(db.Integer)
final_disposition = db.Column(db.Integer)
editor_decision = db.Column(db.Integer)
uid = db.relationship("User",
foreign_keys='NewSubmission.user_id',
backref='articles')
editor_in_chief = db.relationship(
"User",
foreign_keys='NewSubmission.editor_in_chief_id',
backref='editor_in_chief')
associate_editor = db.relationship(
"User",
foreign_keys='NewSubmission.associate_editor_id',
backref='associate_editor')
@property
def article_id(self):
return "CC-{0}-{1}".format(datetime.now().year, self.id)
def __repr__(self):
return '<NewSubmission id={0}, title={1}, user={2}>'.format(
self.article_id, self.title, self.uid)
class Treatment(Base):
id = db.Column(db.Integer, nullable=False, autoincrement=True, primary_key=True)
price = db.Column(db.Float)
register_id = db.Column(db.Integer, db.ForeignKey('register.id'), primary_key=True)
drug_id = db.Column(db.Integer, db.ForeignKey('drugs.id'), primary_key=True)
project_id = db.Column(db.Integer, db.ForeignKey('projects.id'), primary_key=True)
register = db.relationship('Register', backref='treatment')
drugs = db.relationship('Drugs', backref='treatment')
projects = db.relationship('Projects', backref='treatment')
class Register(Base):
id = db.Column(db.Integer, nullable=False, primary_key=True)
patient_name = db.Column(db.Text)
gender = db.Column(db.Text)
phone = db.Column(db.BigInteger)
first_level_department_id = db.Column(db.SmallInteger, db.ForeignKey('first_level_department.id'))
first_level_department = db.relationship('FirstLevelDepartment', backref='register')
second_level_department_id = db.Column(db.SmallInteger, db.ForeignKey('second_level_department.id'))
second_level_department = db.relationship('SecondLevelDepartment', backref='register')
class Editorial_topic(Base):
__tablename__ = 'editorial_topic'
index = Column(Integer, primary_key=True, autoincrement=True)
# TODO: list campaign table schema here
editorial_topic_id = Column(Integer, unique=True)
editorial_topic_name = Column(String)
editorial_topic_description = Column(String)
tags = db.relationship('Tag',
secondary=editorial_topic_tag,
backref=db.backref('editorial_topics',
lazy='dynamic'))
articles = db.relationship('Article',
secondary=editorial_topic_article,
backref=db.backref('editorial_topics',
lazy='dynamic'))
def keys(self):
self.hide('index')
return self.fields
@staticmethod
def create_editorial_topic(campaign_id,
editorial_topic_id,
editorial_topic_name,
editorial_topic_description,
editorial_topic_tags=None):
with db.auto_commit():
new_editorial_topic = Editorial_topic(
editorial_topic_id=editorial_topic_id,
editorial_topic_name=editorial_topic_name,
editorial_topic_description=editorial_topic_description)
linked_campaign = Campaign.query.filter_by(
campaign_id=campaign_id).first_or_404()
new_editorial_topic.campaigns.append(linked_campaign)
db.session.add(new_editorial_topic)
return linked_campaign
@staticmethod
def delete_topic(editorial_topic_id):
with db.auto_commit():
delete_editorial_topic = Editorial_topic.query.filter_by(
editorial_topic_id=editorial_topic_id).first_or_404()
db.session.delete(delete_editorial_topic)
return delete_editorial_topic
@staticmethod
def delete_article_from_topic(editorial_topic_id, article_id):
with db.auto_commit():
target_editorial_topic = Editorial_topic.query.filter_by(
editorial_topic_id=editorial_topic_id).first_or_404()
for article in target_editorial_topic.articles:
if article.article_id == article_id:
target_editorial_topic.articles.remove(article)
return target_editorial_topic
class Department(Base):
__tablename__ = 'department'
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(32), index=True)
parentId = Column(Integer, ForeignKey('department.id'))
depPath = Column(String(255))
enabled = Column(Boolean)
leader = Column(String(32))
isParent = Column(Boolean)
employee = db.relationship('Employee', backref='department', lazy=True)
jobLevel = db.relationship('JobLevel', backref='department', lazy=True)
children = db.relationship('Department', back_populates="parent")
parent = db.relationship('Department', back_populates='children', remote_side=[id])
class Event(db.Model, CRUD):
__tablename__ = "events"
id = db.Column(db.Integer, primary_key=True)
eventType = db.Column(db.Enum(EventTypesEnum), nullable=False)
dateTime = db.Column(db.DateTime, nullable=False)
userId = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
user = db.relationship("User")
roomId = db.Column(db.Integer, db.ForeignKey("rooms.id"), nullable=False)
room = db.relationship("Room")
def __init__(self):
self.lastUpdate = datetime.now()
self.active = True
class Sala(db.Model, CRUD):
__tablename__ = "sala"
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(20), unique=True)
horarios = db.relationship("Horario", cascade="delete")
acesso = db.relationship("DireitoAcesso", cascade="delete")
last_update = db.Column(db.DateTime(), nullable=False)
alive = db.Column(db.Boolean, nullable=False)
def __init__(self, nome):
self.nome = nome
self.last_update = datetime.now()
self.alive = True
class Room(db.Model, CRUD):
__tablename__ = "rooms"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=True)
schedules = db.relationship("Schedule", backref="room.id", cascade="delete", lazy=False)
users = db.relationship("RoomUser", cascade="all", lazy=False)
lastUpdate = db.Column(db.DateTime(), nullable=False)
lastSynchronization = db.Column(db.DateTime(), nullable=True)
lastAddress = db.Column(db.String(100), nullable=True)
active = db.Column(db.Boolean, nullable=False)
def __init__(self):
self.lastUpdate = datetime.now()
self.active = True
class RoomUser(db.Model, CRUD):
__tablename__ = "roomsUsers"
userId = db.Column(db.Integer, db.ForeignKey('users.id'), primary_key=True)
roomId = db.Column(db.Integer, db.ForeignKey('rooms.id'), primary_key=True)
user = db.relationship("User")
room = db.relationship("Room")
lastUpdate = db.Column(db.DateTime(), nullable=False)
active = db.Column(db.Boolean, nullable=False)
description = db.Column(db.String(255), unique=True)
def __init__(self):
self.lastUpdate = datetime.now()
self.active = True
class Article(Base):
__tablename__ = 'article'
index = Column(Integer, primary_key=True, autoincrement=True)
# TODO: list campaign table schema here
article_id = Column(Integer, unique=True)
article_importance = Column(Float)
author = Column(String)
source = Column(String)
title = Column(String)
url = Column(Text)
time_created = Column(Date)
thumbnail_url = Column(Text)
abstract = Column(Text)
tags = db.relationship('Tag',
secondary=article_tag,
backref=db.backref('articles', lazy='dynamic'))
def keys(self):
self.hide('index')
return self.fields
@staticmethod
def upload_and_parse_url(editorial_topic_id, target_url):
with db.auto_commit():
linked_editorial_topic = Editorial_topic.query.filter_by(
editorial_topic_id=editorial_topic_id).first_or_404()
linked_article = Article(url=target_url)
linked_editorial_topic.articles.append(linked_article)
return linked_editorial_topic
@staticmethod
def create_article(editorial_topic_id, article_id):
with db.auto_commit():
linked_editorial_topic = Editorial_topic.query.filter_by(
editorial_topic_id=editorial_topic_id).first_or_404()
new_article = Article(article_id=article_id)
new_article.editorial_topics.append(linked_editorial_topic)
db.session.add(new_article)
return linked_editorial_topic
@staticmethod
def delete_tag_from_article(article_id, article_tags):
with db.auto_commit():
target_article = Article.query.filter_by(
article_id=article_id).first_or_404()
for delete_tag in article_tags:
for exist_tag in target_article.tags:
if exist_tag.index == delete_tag['tag_id']:
target_article.tags.remove(exist_tag)
break
return target_article
@staticmethod
def edit_article_importance(article_id, article_importance):
with db.auto_commit():
target_article = Article.query.filter_by(
article_id=article_id).first_or_404()
target_article.article_importance = article_importance
return target_article
class ArticleType(db.Model):
__tablename__ = 'article_type'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
articles = db.relationship("NewSubmission", backref='type')
def __repr__(self):
return '<ArticleType id={0}, name={1}>'.format(self.id, self.name)
class JobLevel(Base):
__tablename__ = 'job_level'
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(32))
titleLevel = Column(Enum('实习', '高级', '中级', '初级', '管理层'))
enabled = Column(Boolean)
departmentId = Column(Integer, ForeignKey('department.id'))
employee = db.relationship('Employee', backref='job_level', lazy=True)
class CountryList(db.Model):
__tablename__ = 'countries'
id = db.Column(db.Integer, primary_key=True)
country_code = db.Column(db.String(16), nullable=False)
country_name = db.Column(db.String(256), nullable=False)
users = db.relationship("User", backref="country")
def __repr__(self):
return '<Country id={0}, country_code={1}, country_name={2}>'.format(
self.id, self.country_code, self.country_name)
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(32), unique=True, index=True)
holder = Column(String(32))
holderId = Column(Integer, ForeignKey('employee.id'))
phone = Column(String(11))
password_hash = Column(String(128))
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
lastLoginTime = db.Column(db.DateTime) # 上次登录时间
lastLoginIp = db.Column(db.String(32), nullable=True) # 上次登录IP
currentLoginIp = db.Column(db.String(32), nullable=True) # 当前登录IP
userRole = roles_users
transferRecord = db.relationship('EmployeeTransfer',
backref='transfer_operator',
lazy=True)
operateLog = db.relationship('OperateLog', backref='user', lazy=True)
def __repr__(self):
return '<User %r>' % self.username
@property
def password(self):
raise AttributeError("password is not a readable attribute!")
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
"""验证密码"""
return check_password_hash(self.password_hash, password)
@staticmethod
def verify(username, password):
user = User.query.filter_by(username=username).first_or_404()
if not user.verify_password(password):
raise AuthFailed(msg="登录验证失败!", error_code=1006)
role = user.roles
return {'uid': user.id, 'roles': role, 'holderId': user.holderId}
class SecondLevelDepartment(Base):
id = db.Column(db.SmallInteger,
nullable=False,
autoincrement=True,
primary_key=True)
name = db.Column(db.Text, nullable=False)
phone = db.Column(db.BigInteger)
first_level_department_id = db.Column(
db.SmallInteger, db.ForeignKey('first_level_department.id'))
first_level_department = db.relationship('FirstLevelDepartment',
backref='second_level_department')
class Role(Base):
__tablename__ = 'roles'
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(80), unique=True)
description = Column(String(255))
menus = db.relationship('Menu',
secondary=role_menu,
backref=db.backref('roles', lazy='dynamic'))
roleMenu = role_menu
def __repr__(self):
return '<Role %r>' % self.name
class Schedule(db.Model, CRUD):
__tablename__ = "schedules"
id = db.Column(db.Integer, primary_key=True)
roomId = db.Column(db.Integer, db.ForeignKey("rooms.id"), nullable=False)
room = db.relationship("Room")
userType = db.Column(db.Enum(UserTypesEnum), nullable=False)
dayOfWeek = db.Column(db.Enum(DaysOfWeekEnum), nullable=False)
beginTime = db.Column(db.Time, nullable=False)
endTime = db.Column(db.Time, nullable=False)
lastUpdate = db.Column(db.DateTime, nullable=False)
active = db.Column(db.Boolean, nullable=False)
class UserAndOA(Base):
__tablename__ = 'user_and_oa'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.String(255), unique=True) # oa的i d
username = db.Column(db.String(255))
userphone = db.Column(db.String(255))
ningben_id = db.Column(db.String(255))
department = db.Column(db.String(255))
img_url = db.Column(db.String(255))
user_text = db.Column(db.String(255))
grade = db.Column(db.Integer, default=0)
role = db.Column(db.Integer, default=0) # 角色 0 为业务员 1为后台 2职能
qr_code = db.Column(db.String(255)) # 二维码
deletes = db.Column(db.Integer, default=0) # 软删除
leave_job = db.Column(db.Integer, default=-1) # 离职状态（-1新员工, 1 在职， 0离职）
open_id = db.Column(db.String(255)) # 微信开发open_id
union_id = db.Column(db.String(255)) # 微信开放平台union_id
advert = db.Column(db.String(255)) # 公众号尾巴
puermission = db.relationship("PermissionUser",
secondary=PermissionAndUserOA)
team_value = db.relationship("NbTeam", secondary=NbTeam_And_User)
# 获取token，有效时间单位s
def fa_oa_token(self, expiration=30 * 24 * 60 * 60):
s = Serializer(x, expires_in=expiration)
return s.dumps({'id': self.id})
# 解析token，确认登录的用户身份
@staticmethod
def token(token):
s = Serializer(x)
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = UserAndOA.query.get(data['id'])
return user
class TrainingProgram(Base):
__tablename__ = 'training_program'
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(32), index=True)
content = Column(String(255))
address = Column(String(64))
beginDate = Column(Date)
endDate = Column(Date)
isPublish = Column(Boolean)
isEnd = Column(Boolean)
isFinishAssess = Column(Boolean)
trainingPeople = db.relationship('EmployeeTrainingRecord',
backref='training_program',
lazy=True)
class DireitoAcesso(db.Model, CRUD):
__tablename__ = "direito_acesso"
id = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer,
db.ForeignKey("usuario.id"),
nullable=False)
id_sala = db.Column(db.Integer, db.ForeignKey("sala.id"), nullable=False)
nome_sala = db.relationship("Sala", uselist=False)
alive = db.Column(db.Boolean, nullable=False)
def __init__(self, id_usuario, id_sala):
self.id_usuario = id_usuario
self.id_sala = id_sala
self.alive = True
class Usuario(db.Model, CRUD):
__tablename__ = "usuario"
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(80), nullable=False)
tipo = db.Column(db.Enum(TipoUsuario), nullable=False)
email = db.Column(db.String(100), nullable=False, unique=True)
rfid = db.Column(db.String(16), nullable=False, unique=True)
direito_acesso = db.relationship("DireitoAcesso", cascade="delete")
last_update = db.Column(db.DateTime(), nullable=False)
alive = db.Column(db.Boolean, nullable=False)
def __init__(self, nome, email, rfid, tipo):
self.nome = nome
self.email = email
self.rfid = rfid
self.tipo = tipo
self.alive = True
self.last_update = datetime.now()
class User(Base):
__tablename__ = 'user_table'
index = Column(Integer, primary_key=True, autoincrement=True)
# TODO: list campaign table schema here
user_id = Column(Integer, unique=True)
campaigns = db.relationship('Campaign',
secondary=user_campaign,
backref=db.backref('users', lazy='dynamic'))
def keys(self):
self.hide('index')
return self.fields
@staticmethod
def create_user(user_id):
with db.auto_commit():
new_user = User(user_id=user_id)
db.session.add(new_user)
return 'create user success'
class User(Base):
id = Column(Integer, primary_key=True, autoincrement=True)
openid = Column(String(50), unique=True)
unionid = Column(String(50), unique=True)
email = Column(String(24), unique=True)
nickname = Column(String(24), unique=True)
extend = Column(String(255))
auth = Column(SmallInteger, default=1)
_user_address = db.relationship('UserAddress', backref='author', lazy='dynamic')
_password = Column('password', String(100))
def keys(self):
# return ['id', 'email', 'nickname', 'auth', 'user_address']
self.hide('openid', 'unionid', '_password', 'extend').append('user_address')
return self.fields
@property
def password(self):
return self._password
@property
def user_address(self):
return self._user_address.first()
@password.setter
def password(self, raw):
self._password = generate_password_hash(raw)
def save_address(self, address_info):
with db.auto_commit():
# address = UserAddress.query.filter_by(user_id=self.id).first()
address = self._user_address.first()
if not address:
address = UserAddress(author=self)
address.name = address_info.name
address.mobile = address_info.mobile
address.province = address_info.province
address.city = address_info.city
address.country = address_info.country
address.detail = address_info.detail
db.session.add(address)
@staticmethod
def register_by_email(nickname, account, secret):
"""邮箱注册"""
with db.auto_commit():
user = User()
user.nickname = nickname
user.email = account
user.password = secret
db.session.add(user)
@staticmethod
def register_by_wx(account):
"""小程序注册"""
with db.auto_commit():
user = User()
user.openid = account
db.session.add(user)
db.session.flush()
return user
@staticmethod
def register_by_wx_open(user_info):
"""微信第三方注册"""
img_filename = HTTP.download_pic(user_info['headimgurl'], type='avatar')
with db.auto_commit():
user = User()
user.openid = user_info['openid']
user.unionid = user_info['unionid']
user.nickname = user_info['nickname']
# user.avatar = img_filename
db.session.add(user)
db.session.flush()
return user
@staticmethod
def verify_by_email(email, password):
user = User.query.filter_by(email=email).first_or_404(
e=UserException(msg='该账号未注册'))
if not user.check_password(password):
raise AuthFailed(msg='密码错误')
scope = 'AdminScope' if user.auth == ScopeEnum.Admin else 'UserScope'
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_wx(code, *args):
ut = WxToken(code)
wx_result = ut.get() # wx_result = {session_key, expires_in, openid}
openid = wx_result['openid']
user = User.query.filter_by(openid=openid).first()
# 如果不在数据库，则新建用户
if not user:
user = User.register_by_wx(openid)
scope = 'AdminScope' if user.auth == ScopeEnum.Admin else 'UserScope'
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_wx_open(code, *args):
# 微信开放平台(第三方)登录
ot = OpenToken(code)
user_info = ot.get()
openid = user_info['openid'] # 用户唯一标识
user = User.query.filter_by(openid=openid).first()
if not user:
user = User.register_by_wx_open(user_info)
scope = 'AdminScope' if ScopeEnum(user.auth) == ScopeEnum.Admin else 'UserScope'
return {'uid': user.id, 'scope': scope}
def check_password(self, raw):
if not self._password:
return False
return check_password_hash(self._password, raw)
class User(Base):
'''用户'''
__tablename__ = 'user'
id = Column(Integer, primary_key=True, autoincrement=True)
openid = Column(String(50), unique=True, comment='小程序唯一ID(单单该小程序)')
unionid = Column(String(50), unique=True, comment='微信唯一ID(全网所有)')
email = Column(String(24), unique=True, comment='邮箱')
# mobile = Column(String(16), unique=True)
nickname = Column(String(24), comment='昵称')
extend = Column(String(255), comment='')
auth = Column(SmallInteger, default=1, comment='权限')
_user_address = db.relationship('UserAddress',
backref='author',
lazy='dynamic')
_password = Column('password', String(100), comment='密码')
def __repr__(self):
return '<User(id={0}, nickname={1})>'.format(self.id, self.nickname)
def keys(self):
self.hide('openid', 'unionid', '_password',
'extend').append('user_address')
return self.fields
@property
def password(self):
return self._password
@password.setter
def password(self, raw):
self._password = generate_password_hash(raw)
@property
def user_address(self):
return self._user_address.first()
def save_address(self, address_info):
with db.auto_commit():
# address = UserAddress.query.filter_by(user_id=self.id).first()
address = self.user_address
if not address:
address = UserAddress(author=self)
address.update(commit=True, **address_info)
db.session.add(address)
@staticmethod
def register_by_email(nickname, account, secret):
"""邮箱注册"""
with db.auto_commit():
user = User(nickname=nickname, email=account, password=secret)
db.session.add(user)
return user
@staticmethod
def register_by_mobile(nickname, account, secret):
"""手机号注册"""
with db.auto_commit():
user = User(nickname=nickname, mobile=account, password=secret)
db.session.add(user)
return user
@staticmethod
def register_by_wx_mina(account):
"""小程序注册"""
with db.auto_commit():
user = User(openid=account)
db.session.add(user)
return user
@staticmethod
def register_by_wx_open(user_info):
"""微信第三方注册"""
with db.auto_commit():
user = User()
user.openid = user_info['openid']
user.unionid = user_info['unionid']
user.nickname = user_info['nickname']
user.avatar = user_info['headimgurl']
db.session.add(user)
return user
@staticmethod
def verify_by_email(email, password):
user = User.query.filter_by(email=email) \
.first_or_404(e=UserException(msg='该账号未注册'))
if not user.check_password(password):
raise AuthFailed(msg='密码错误')
scope = 'AdminScope' if ScopeEnum(
user.auth) == ScopeEnum.ADMIN else 'UserScope'
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_mobile(mobile, password):
user = User.query.filter_by(mobile=mobile) \
.first_or_404(e=UserException(msg='该账号未注册'))
if not user.check_password(password):
raise AuthFailed(msg='密码错误')
scope = 'AdminScope' if ScopeEnum(
user.auth) == ScopeEnum.ADMIN else 'UserScope'
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_wx_mina(code, *args):
ut = WxToken(code)
wx_result = ut.get() # wx_result = {session_key, expires_in, openid}
openid = wx_result['openid']
user = User.query.filter_by(openid=openid).first()
# 如果不在数据库，则新建用户
if not user:
user = User.register_by_wx_mina(openid)
scope = 'AdminScope' if ScopeEnum(
user.auth) == ScopeEnum.ADMIN else 'UserScope'
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_wx_open(code, *args):
# 微信开放平台(第三方)登录
ot = OpenToken(code)
user_info = ot.get()
openid = user_info['openid'] # 用户唯一标识
user = User.query.filter_by(openid=openid).first()
if not user:
user = User.register_by_wx_open(user_info)
scope = 'AdminScope' if ScopeEnum(
user.auth) == ScopeEnum.ADMIN else 'UserScope'
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_wx_account(code, *args):
ot = AccountToken(code)
user_info = ot.get()
unionid = user_info['unionid']
user = User.query.filter_by(unionid=unionid).first()
if not user:
user = User.register_by_wx_open(user_info)
scope = 'AdminScope' if ScopeEnum(
user.auth) == ScopeEnum.ADMIN else 'UserScope'
return {'uid': user.id, 'scope': scope}
def check_password(self, raw):
if not self._password:
return False
return check_password_hash(self._password, raw)
class User(db.Model, Base, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
_password = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(64), nullable=False, unique=True)
first_name = db.Column(db.String(32), nullable=False)
middle_name = db.Column(db.String(32))
last_name = db.Column(db.String(32), nullable=False)
title = db.Column(db.String(16), nullable=False)
degree = db.Column(db.String(16))
# nick_name = db.Column(db.String(32))
phone_number = db.Column(db.String(16))
fax_number = db.Column(db.String(16))
secondary_email = db.Column(db.String(64))
institution_phone_number = db.Column(db.String(16))
institution = db.Column(db.String(32))
department = db.Column(db.String(32))
street = db.Column(db.String(64))
city = db.Column(db.String(16), nullable=False)
country_id = db.Column(db.Integer, db.ForeignKey("countries.id"))
state_or_province = db.Column(db.String(16))
zip = db.Column(db.String(32))
# person_classifications todo:这个键作为单独的一张表
person_keywords = db.Column(db.Text, nullable=False)
roles = db.relationship('Role',
secondary=user_roles,
backref=db.backref('users', lazy='dynamic'))
# article = db.relationship('NewSubmission', back_populates='uid')
# editor_in_chief = db.relationship('NewSubmission', back_populates='editor_in_chief')
# associate_editor = db.relationship('NewSubmission', back_populates='associate_editor')
def __repr__(self):
return '<User id={0}, email={1}, roles={2}>'.format(
self.id, self.email, self.roles)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if not self.roles:
if self.email in current_app.config['ADMIN_EMAIL']:
self.roles.append(
Role.query.filter_by(permissions=Permission.ADMIN).first())
if not self.roles:
self.roles.append(Role.query.filter_by(default=True).first())
@property
def password(self):
return AttributeError('password is not a readable attribute')
@password.setter
def password(self, raw):
self._password = generate_password_hash(raw)
def check_password(self, raw):
return check_password_hash(self._password, raw)
def can(self, perm):
role = Role.query.filter_by(permissions=perm).first()
if role in self.roles:
return True
else:
return False
def is_admin(self):
return self.can(Permission.ADMIN)
class UserIdentity(Base):
id = db.Column(db.Integer, nullable=False, primary_key=True)
name = db.Column(db.Text)
user = db.relationship('User', backref='user_identity')
class User(Base):
id = Column(Integer, primary_key=True, autoincrement=True)
openid = Column(String(50), unique=True)
email = Column(String(24), unique=True)
nickname = Column(String(24), unique=True)
extend = Column(String(255))
auth = Column(SmallInteger, default=1)
_user_address = db.relationship('UserAddress',
backref='author',
lazy='dynamic')
_password = Column('password', String(100))
def keys(self):
# return ['id', 'email', 'nickname', 'auth', 'user_address']
self.hide('openid', '_password', 'extend').append('user_address')
return self.fields
@property
def password(self):
return self._password
@property
def user_address(self):
return self._user_address.first()
@password.setter
def password(self, raw):
self._password = generate_password_hash(raw)
def save_address(self, address_info):
with db.auto_commit():
# address = UserAddress.query.filter_by(user_id=self.id).first()
address = self._user_address.first()
if not address:
address = UserAddress(author=self)
address.name = address_info.name
address.mobile = address_info.mobile
address.province = address_info.province
address.city = address_info.city
address.country = address_info.country
address.detail = address_info.detail
db.session.add(address)
@staticmethod
def register_by_email(nickname, account, secret):
with db.auto_commit():
user = User()
user.nickname = nickname
user.email = account
user.password = secret
db.session.add(user)
@staticmethod
def register_by_wx(account):
with db.auto_commit():
user = User()
user.openid = account
db.session.add(user)
return User.query.filter_by(openid=account).first()
@staticmethod
def verify_by_email(email, password):
user = User.query.filter_by(email=email).first_or_404()
if not user.check_password(password):
raise AuthFailed()
scope = 'AdminScope' if user.auth == ScopeEnum.Admin else 'UserScope'
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_wx(code, *args):
ut = UserToken(code)
wx_result = ut.get()
openid = wx_result['openid']
user = User.query.filter_by(openid=openid).first()
if not user:
user = User.register_by_wx(openid)
scope = 'AdminScope' if user.auth == ScopeEnum.Admin else 'UserScope'
return {'uid': user.id, 'scope': scope}
def check_password(self, raw):
if not self._password:
return False
return check_password_hash(self._password, raw)
class Campaign(Base):
__tablename__ = 'campaign'
index = Column(Integer, primary_key=True, autoincrement=True)
# TODO: list campaign table schema here
# user_id = Column(UUID)
# token = Column(String)
campaign_id = Column(Integer, unique=True)
campaign_name = Column(String)
campaign_obj_type = Column(
Enum('私域促活/留存', '私域拉新', '裂变', name='campaign objective type'))
campaign_time_start = Column(Date)
campaign_time_end = Column(Date)
campaign_core_metric_type = Column(String)
campaign_core_metric_value = Column(Float)
editorial_topics = db.relationship('Editorial_topic',
secondary=campaign_editorial_topic,
backref=db.backref('campaigns',
lazy='dynamic'))
def keys(self):
self.hide('index')
return self.fields
@staticmethod
def create_campaign(user_id, campaign_id, campaign_name, campaign_obj_type,
campaign_time_start, campaign_time_end):
date_number_start = list(
map(int,
re.compile(r'\d+').findall(campaign_time_start)))
date_number_end = list(
map(int,
re.compile(r'\d+').findall(campaign_time_end)))
campaign_time_start = datetime(date_number_start[0],
date_number_start[1],
date_number_start[2])
campaign_time_end = datetime(date_number_end[0], date_number_end[1],
date_number_end[2])
with db.auto_commit():
new_campaign = Campaign(campaign_id=campaign_id,
campaign_name=campaign_name,
campaign_obj_type=campaign_obj_type,
campaign_time_start=campaign_time_start,
campaign_time_end=campaign_time_end)
linked_user = User.query.filter_by(user_id=user_id).first_or_404()
new_campaign.users.append(linked_user)
db.session.add(new_campaign)
return linked_user
@classmethod
def get_campaigns(cls, page=1, size=15):
paginator = Campaign.query.paginate(page=page,
per_page=size,
error_out=True)
return {
'total': paginator.total,
'current_page': paginator.page,
'items': paginator.items
}
@classmethod
def get_campaigns_by_user_token(cls, user_id, token, page=1, size=15):
paginator = Campaign.query.filter_by(
user_id=user_id, token=token).paginate(page=page,
per_page=size,
error_out=True)
return {
'total': paginator.total,
'current_page': paginator.page,
'items': paginator.items
}
class User(Base):
'''用户'''
__tablename__ = 'user'
id = Column(Integer, primary_key=True, autoincrement=True)
openid = Column(String(50), unique=True, comment='小程序唯一ID(单单该小程序)')
unionid = Column(String(50), unique=True, comment='微信唯一ID(全网所有)')
email = Column(String(24), unique=True, comment='邮箱')
# mobile = Column(String(16), unique=True)
nickname = Column(String(24), comment='昵称')
extend = Column(String(255), comment='')
auth = Column(SmallInteger, default=1, comment='权限')
_user_address = db.relationship('UserAddress', backref='author', lazy='dynamic')
_password = Column('password', String(100), comment='密码')
def __repr__(self):
return '<User(id={0}, nickname={1})>'.format(self.id, self.nickname)
def keys(self):
self.hide('openid', 'unionid', '_password', 'extend').append('user_address', 'auth_scope')
return self.fields
@property
def password(self):
return self._password
@password.setter
def password(self, raw):
self._password = generate_password_hash(raw)
@property
def user_address(self):
return self._user_address.first()
@property
def auth_scope(self):
return Scope.match_user_scope(self.auth, type='cn')
def save_address(self, address_info):
address = self.user_address
if not address:
address = UserAddress(author=self)
return address.update(**address_info)
@staticmethod
def register_by_email(nickname, account, secret):
"""邮箱注册"""
form = {'nickname': nickname, 'email': account, 'password': secret}
return User.create(**form)
@staticmethod
def register_by_mobile(nickname, account, secret):
"""手机号注册"""
form = {'nickname': nickname, 'mobile': account, 'password': secret}
return User.create(**form)
@staticmethod
def register_by_wx_mina(account):
"""小程序注册"""
form = {'openid': account}
return User.create(**form)
@staticmethod
def register_by_wx_open(form):
"""
微信第三方注册
:param form: 属性包含(openid、unionid、nickname、headimgurl)
:return:
"""
return User.create(**form)
@staticmethod
def verify_by_email(email, password):
user = User.query.filter_by(email=email) \
.first_or_404(e=UserException(msg='该账号未注册'))
if not user.check_password(password):
raise AuthFailed(msg='密码错误')
scope = Scope.match_user_scope(auth=user.auth)
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_mobile(mobile, password):
user = User.query.filter_by(mobile=mobile) \
.first_or_404(e=UserException(msg='该账号未注册'))
if not user.check_password(password):
raise AuthFailed(msg='密码错误')
scope = Scope.match_user_scope(auth=user.auth)
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_wx_mina(code, *args):
ut = WxToken(code)
wx_result = ut.get() # wx_result = {session_key, expires_in, openid}
openid = wx_result['openid']
user = User.query.filter_by(openid=openid).first()
# 如果不在数据库，则新建用户
if not user:
user = User.register_by_wx_mina(openid)
scope = Scope.match_user_scope(auth=user.auth)
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_wx_open(code, *args):
# 微信开放平台(第三方)登录
ot = OpenToken(code)
user_info = ot.get()
openid = user_info['openid'] # 用户唯一标识
user = User.query.filter_by(openid=openid).first()
if not user:
user = User.register_by_wx_open(form=user_info)
scope = Scope.match_user_scope(auth=user.auth)
return {'uid': user.id, 'scope': scope}
@staticmethod
def verify_by_wx_account(code, *args):
ot = AccountToken(code)
user_info = ot.get()
unionid = user_info['unionid']
user = User.query.filter_by(unionid=unionid).first()
if not user:
user = User.register_by_wx_open(user_info)
scope = Scope.match_user_scope(auth=user.auth)
return {'uid': user.id, 'scope': scope}
@classmethod
def get_current_user(cls):
return cls.get(id=g.user.uid)
def check_password(self, raw):
if not self._password:
return False
return check_password_hash(self._password, raw)
