class Course_Sign(db.Model):
__tablename__ = 'Course_Sign'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
SignId = db.Column(db.Integer, db.ForeignKey('Pos_SignData.SignId'))
CourseId = db.Column(db.Integer, db.ForeignKey('Course.CourseId'))
Studentid = db.Column(db.Integer, db.ForeignKey('Student.Studentid'))
longitude = db.Column(db.Numeric)
latitude = db.Column(db.Numeric)
SignTime = db.Column(db.String(255))
Status = db.Column(db.String(255))
def __init__(self, SignId, CourseId, Studentid, longitude, latitude,
Status):
self.SignId = SignId
self.CourseId = CourseId
self.Studentid = Studentid
self.longitude = longitude
self.latitude = latitude
self.Status = Status
def to_json(self):
json_data = {
'SignId': self.SignId,
'CourseId': self.CourseId,
'Studentid': self.Studentid,
'longitude': self.longitude,
'latitude': self.latitude,
'SignTime': self.SignTime,
'Status': self.Status,
}
return json.dumps(json_data)
class Employee(db.Model):
"""docstring for Employee"""
__tablename__ = 'employee'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
project_id = db.Column(db.Integer, nullable=True)
emp_name = db.Column(db.String(255), nullable=True)
emp_tel = db.Column(db.String(255))
emp_work_status = db.Column(db.Integer, nullable = True)
emp_duty = db.Column(db.Text(200))
emp_dept = db.Column(db.String(255))
emp_position = db.Column(db.String(255))
emp_number = db.Column(db.String(255))
def __init__(self, project_id, emp_name,
emp_tel, emp_work_status, emp_duty, emp_dept, emp_position, emp_number):
self.project_id = project_id
self.emp_name = emp_name
self.emp_tel = emp_tel
self.emp_work_status = emp_work_status
self.emp_duty = emp_duty
self.emp_dept = emp_dept
self.emp_position = emp_position
self.emp_number = emp_number
def to_json(self):
json_data = {
'id': self.id,
'project_id': self.project_id,
'emp_name': self.emp_name,
'emp_tel': self.emp_tel,
'emp_work_status': self.emp_work_status,
'emp_duty': self.emp_duty,
'emp_dept': self.emp_dept,
'emp_position': self.emp_position,
'emp_number': self.emp_number
}
return json_data
class STUDENT(db.Model):
__tablename__ = 'Student'
Studentid = db.Column(db.Integer, primary_key=True, autoincrement=True)
Studentname = db.Column(db.String(255))
StudentNumber = db.Column(db.Integer, unique=True)
Major = db.Column(db.String(255))
Schooling = db.Column(db.String(255))
Userid = db.Column(db.Integer, db.ForeignKey('User.Userid'))
Class = db.Column(db.String(255))
def __init__(self, Studentname, StudentNumber, Major, Schooling, Userid,
Class):
self.Studentname = Studentname
self.StudentNumber = StudentNumber
self.Major = Major
self.Schooling = Schooling
self.Userid = Userid
self.Class = Class
def to_json(self):
json_data = {
'Studentid': self.Studentid,
'Studentname': self.Studentname,
'StudentNumber': self.StudentNumber,
'Major': self.Major,
'Schooling': self.Schooling,
'Userid': self.Userid,
'Class': self.Class,
}
return json.dumps(json_data)
class SubProject(db.Model):
"""docstring for SubProject"""
__tablename__ = 'sub_project'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
project_id = db.Column(db.Integer, nullable=True)
sub_project_name = db.Column(db.String(255), nullable=True)
sub_project_status = db.Column(db.String(255), nullable=True)
start_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
def __init__(self, project_id, sub_project_name, sub_project_status,
start_time, end_time):
self.project_id = project_id
self.sub_project_name = sub_project_name
self.sub_project_status = sub_project_status
self.start_time = start_time
self.end_time = end_time
def to_json(self):
json_data = {
'id': self.id,
'project_id': self.project_id,
'sub_project_name': self.sub_project_name,
'sub_project_status': self.sub_project_status,
'start_time': self.start_time,
'end_time': self.end_time,
}
return json_data
class Secmanager(db.Model):
_tablename_ = "secmanager"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
project_id = db.Column(db.Integer, db.ForeignKey('project.id'))
device_name = db.Column(db.String(20))
specification = db.Column(db.String(20))
number = db.Column(db.Integer)
project = db.relationship('Project')
def __init__(self, project_id, device_name, specification, number):
super(Secmanager, self).__init__()
self.project_id = project_id
self.device_name = device_name
self.specification = specification
self.number = number
def to_json(self):
json_data = {
'id': self.id,
'project_id': self.project_id,
'device_name': self.device_name,
'specification': self.specification,
'number': self.number,
'project': self.project.to_json()
}
return json_data
class UpdataLog(db.Model):
__tablename__ = 'update_image_log'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
updatetime = db.Column(db.DateTime)
loginname = db.Column(db.String(255), nullable=True)
belong = db.Column(db.String(255), nullable=True)
reason = db.Column(db.String(255), nullable=True)
op = db.Column(db.Integer, nullable=True)
def __init__(self, updatetime, loginname, belong, reason, op):
self.updatetime = updatetime
self.loginname = loginname
self.belong = belong
self.reason = reason
self.op = op
def to_json(self):
json_data = {
'id': self.id,
'updatetime': self.updatetime,
'belong': self.belong,
'reason': self.reason,
'loginname': self.loginname,
'op': self.op
}
return json_data
class SysMonitor(db.Model):
"""docstring for ClassName"""
__tablename__ = 'sysmonitor'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
sections_id = db.Column(db.Integer, nullable=True)
stresses = db.Column(db.String(255))
shape = db.Column(db.String(255))
temperature = db.Column(db.String(255))
humidity = db.Column(db.String(255))
windpower = db.Column(db.String(255))
day = db.Column(db.DateTime, nullable=True)
def __init__(self, sections_id, stresses, shape, temperature, humidity,
windpower, day):
super(Sections, self).__init__()
self.sections_id = sections_id
self.stresses = stresses
self.shape = shape
self.temperature = temperature
self.humidity = humidity
self.windpower = windpower
self.day = day
def to_json(self):
json_data = {
'id': self.id,
'sections_id': self.sections_id,
'stresses': self.stresses,
'shape': self.shape,
'temperature': self.temperature,
'humidity': self.humidity,
'windpower': self.windpower,
'day': self.day
}
return json_data
class Course_Sign(db.Model):
__tablename__ = 'Course_Sign'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
SignId = db.Column(db.Integer, db.ForeignKey('SignData.SignId'))
CourseId = db.Column(db.Integer, db.ForeignKey('Course.CourseId'))
Studentid = db.Column(db.Integer, db.ForeignKey('STUDENT.Studentid'))
Place = db.Column(db.String(255))
SignData = db.Column(db.String(255))
Status = db.Column(db.String(255))
def __init__(self, SignId, CourseId, Studentid, Place, Status):
self.SignId = SignId
self.CourseId = CourseId
self.Studentid = Studentid
self.Place = Place
self.Status = Status
def to_json(self):
json_data = {
'SignId': self.SignId,
'CourseId': self.CourseId,
'Studentid': self.Studentid,
'Place': self.Place,
'SignData': self.SignData,
'Status': self.Status,
}
return json.dumps(json_data)
class OPmenu(db.Model):
__tablename__ = 'OPmenu'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
code = db.Column(db.String(16), unique=True)
description = db.Column(db.String(256), unique=True)
def __init__(self, code, description):
self.code = code
self.description = description
def to_json(self):
json_data = {
'id': self.id,
'code': self.code,
'desc': self.description
}
return json.dumps(json_data)
def get_opmenu_detail(self):
opmenu_detail = MenuDetail.query.filter_by(
MenuDetailID=self.id).order_by(MenuDetail.position.asc())
all_data = []
for data in opmenu_detail:
data = data.to_json()
data = json.loads(data)
all_data.append(data)
return json.dumps(all_data)
class CookieAuth(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.ForeignKey("user.username"))
cookie = db.Column(db.String(4096), nullable=False)
def __repr__(self):
return "<CookieAuth {}>".format(self.cookie)
class Teacher(db.Model):
__tablename__ = 'Teacher'
TeachId = db.Column(db.Integer, primary_key=True, autoincrement=True)
TeachName = db.Column(db.String(255), unique=True)
TeachNumber = db.Column(db.Integer)
Userid = db.Column(db.Integer, db.ForeignKey('User.Userid'))
def __init__(self, TeachName, TeachNumber, Userid):
self.TeachName = TeachName
self.TeachNumber = TeachNumber
self.Userid = Userid
def to_json(self):
json_data = {
'TeachId': self.TeachId,
'TeachName': self.TeachName,
'TeachNumber': self.TeachNumber,
'Userid': self.Userid
}
return json.dumps(json_data)
def get_TeachName_TeachNumber(self):
return str(self.TeachName), str(self.TeachNumber)
def get_TeachId(self):
return int(self.TeachId)
class MENU(db.Model):
__tablename__ = 'Menu'
Menuid = db.Column(db.Integer, primary_key=True, autoincrement=True)
Menuname = db.Column(db.String(255), unique=True)
URL = db.Column(db.String(255))
icon = db.Column(db.String(255))
roleid = db.Column(db.Integer)
def to_json(self):
json_data = {
'Menuid': self.Menuid,
'text': self.Menuname,
'link': self.URL,
'icon': self.icon,
'children': []
}
return json.dumps(json_data)
class Employee(db.Model):
"""docstring for Employee"""
__tablename__ = 'employee'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
employee_name = db.Column(db.String(255), nullable=True)
employee_number = db.Column(db.String(255), nullable=True)
employee_tel = db.Column(db.String(255))
employee_id_number = db.Column(db.String(255))
employee_dept = db.Column(db.String(255))
employee_job = db.Column(db.String(255))
employee_project = db.Column(db.String(255))
def __init__(self, employee_name, employee_number, employee_tel, employee_id_number, employee_dept, employee_job, employee_project):
super(Employee, self).__init__()
self.employee_name = employee_name
self.employee_number = employee_number
self.employee_tel = employee_tel
self.employee_id_number = employee_id_number
self.employee_dept = employee_dept
self.employee_job = employee_job
self.employee_project = employee_project
def to_json(self):
json_data = {
'id' : self.id,
'employee_name': self.employee_name,
'employee_number': self.employee_number,
'employee_tel': self.employee_tel,
'employee_id_number': self.employee_id_number,
'employee_dept': self.employee_dept,
'employee_job': self.employee_job,
'employee_project' :self.employee_project
}
return json_data
class Sections(db.Model):
"""docstring for ClassName"""
__tablename__ = 'sections'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
sectionsname = db.Column(db.String(255), nullable=True)
def __init__(self, sectionsname):
super(Sections, self).__init__()
self.sectionsname = sectionsname
class Post(db.Model):
id = db.Column(db.Integer, primary_key = True)
title = db.Column(db.String(100), nullable = False)
date_posted = db.Column(db.DateTime, nullable = False, default = datetime.utcnow)
content = db.Column(db.Text, nullable = False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable = False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class Project(db.Model):
"""docstring for ClassName"""
__tablename__ = 'project'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
item_name = db.Column(db.String(255), nullable=True)
item_img_href = db.Column(db.String(255), nullable=True)
def __init__(self, item_name, item_img_href):
self.item_name = item_name
self.item_img_href = item_img_href
def to_json(self):
json_data = {
'id': self.id,
'item_name': self.item_name,
'item_img_href': self.item_img_href,
}
return json_data
class ImagePath(db.Model):
"""docstring for ImagePath"""
__tablename__ = 'image_path'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
pid = db.Column(db.Integer)
belong = db.Column(db.String(255))
image_name = db.Column(db.String(255))
image_url = db.Column(db.String(255))
vedio_up_url = db.Column(db.String(255))
vedio_left_url = db.Column(db.String(255))
vedio_right_url = db.Column(db.String(255))
vedio_bottom_url = db.Column(db.String(255))
abstract = db.Column(db.String(255))
belong_id = db.Column(db.Integer)
def __init__(self,
belong=None,
pid=None,
image_name=None,
image_url=None,
vedio_up_url=None,
vedio_left_url=None,
vedio_right_url=None,
vedio_bottom_url=None,
belong_id=None,
abstract=None):
self.belong = belong
self.pid = pid
self.image_name = image_name
self.image_url = image_url
self.vedio_up_url = vedio_up_url
self.vedio_left_url = vedio_left_url
self.vedio_right_url = vedio_right_url
self.vedio_bottom_url = vedio_bottom_url
self.belong_id = belong_id
self.abstract = abstract
def to_json(self):
json_data = {
'id': self.id,
'pid': self.pid,
'belong': self.belong,
'imageName': self.image_name,
'imageUrl': self.image_url,
'videoUpUrl': self.vedio_up_url,
'videoLeftUrl': self.vedio_left_url,
'videoRightUrl': self.vedio_right_url,
'videoBottomUrl': self.vedio_bottom_url,
'belong_id': self.belong_id,
'abstract': self.abstract
}
return json_data
class PersonalInfoTable(db.Model):
"""个人信息"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.ForeignKey("user.username"))
sex = db.Column(db.String(128), default="2")
age = db.Column(db.Integer, default=0)
height = db.Column(db.Integer, default=0)
wetght = db.Column(db.Integer, default=0)
def __repr__(self):
return "<personalInfo {}>".format(self.name)
class User(db.Model):
'''
id:用户表主键
username:用户的登录名
passwrod: 登录密码需要进行加密
createTIme:用户创建时间
email:用户的电子邮箱，这里主要一QQ邮箱和163邮箱为主
phone:用户电话
'''
id = db.Column(db.Integer, primary_key=True) # 主键
username = db.Column(db.String(128), index=True, unique=True) # 用户名
password = db.Column(db.String(128), nullable=False) # 用户密码
createTime = db.Column(db.DateTime, default=datetime.datetime.now()) # 帐号创建时间
email = db.Column(db.String(128), default=None)
phone = db.Column(db.Integer, default=None)
name = db.Column(db.String(128), default=username)
def __repr__(self):
return "<User {}>".format(self.username)
class Right(db.Model):
__tablename__ = 'Right'
Rightid = db.Column(db.Integer, primary_key=True, autoincrement=True)
Rightname = db.Column(db.String(255))
Rightdescribe = db.Column(db.String(255))
Menuid = db.Column(db.String(255), db.ForeignKey(MENU.Menuid))
def __init__(self, Rightname, Rightdescribe, Menuid):
self.Rightname = Rightname
self.Rightdescribe = Rightdescribe
self.Menuid = Menuid
def to_json(self):
json_data = {
'Rightid': self.Rightid,
'Rightname': self.Rightname,
'Rightdescribe': self.Rightdescribe,
'Menuid': self.Menuid,
}
return json.dumps(json_data)
class USER(db.Model):
__tablename__ = 'User'
Userid = db.Column(db.Integer, primary_key=True, autoincrement=True)
Loginname = db.Column(db.String(255), unique=True)
password = db.Column(db.String(32), unique=True)
Roleid = db.Column(db.Integer)
def __init__(self, Loginname, password, Roleid):
self.Loginname = Loginname
self.password = password
self.Roleid = Roleid
def to_json(self):
json_data = {
'userid': self.Userid,
'loginname': self.Loginname,
'password': self.password,
'roleid': self.Roleid,
}
return json.dumps(json_data)
class StructorInfo(db.Model):
"""docstring for StructorInfo"""
__tablename__ = 'struct_info'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
struct_name = db.Column(db.String(255))
def __init__(self, struct_name):
self.struct_name = struct_name
def to_json(self):
json_data = {'id': self.id, 'struct_name': self.struct_name}
return json_data
class Role(db.Model):
"""docstring for Role"""
__tablename__ = 'Role'
Roleid = db.Column(db.Integer, primary_key=True, autoincrement=True)
Rolename = db.Column(db.String(255), unique=True)
Roledescribe = db.Column(db.String(255))
Islock = db.Column(db.Integer)
def __init__(self, Rolename, Roledescribe, Islock):
self.Rolename = Rolename
self.Roledescribe = Roledescribe
self.Islock = Islock
def to_json(self):
json_data = {
'Roleid': self.Roleid,
'Rolename': self.Rolename,
'Roledescribe': self.Roledescribe,
'Islock': self.Islock,
}
return json.dumps(json_data)
class ParticipantsInfo(db.Model):
"""docstring for participantsInfo"""
__tablename__ = 'participants_info'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
project_id = db.Column(db.Integer, nullable=True)
participants_name = db.Column(db.String(255), nullable=True)
participants_tel = db.Column(db.String(255))
participants_work_status = db.Column(db.Integer, nullable = True)
participants_duty = db.Column(db.Text(200))
participants_dept = db.Column(db.String(255))
participants_position = db.Column(db.String(255))
participants_number = db.Column(db.String(255))
def __init__(self, project_id, participants_name,
participants_tel, participants_work_status, participants_duty, participants_dept, participants_position, participants_number):
self.project_id = project_id
self.participants_name = participants_name
self.participants_tel = participants_tel
self.participants_work_status = participants_work_status
self.participants_duty = participants_duty
self.participants_dept = participants_dept
self.participants_position = participants_position
self.participants_number = participants_number
def to_json(self):
json_data = {
'id': self.id,
'project_id': self.project_id,
'participants_name': self.participants_name,
'participants_tel': self.participants_tel,
'participants_work_status': self.participants_work_status,
'participants_duty': self.participants_duty,
'participants_dept': self.participants_dept,
'participants_position': self.participants_position,
'participants_number': self.participants_number
}
return json_data
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key = True)
username = db.Column(db.String(20), unique = True, nullable = False)
email = db.Column(db.String(120), unique = True, nullable = False)
image_file = db.Column(db.String(120), nullable = False, default = 'default.jpg') # Profile picture, hash image -> string 20 character
password = db.Column(db.String(60), nullable = False)
posts = db.relationship('Post', backref = 'author', lazy = True)
def get_reset_token(self, expires_sec = 1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Course(db.Model):
__tablename__ = 'Course'
CourseId = db.Column(db.Integer, primary_key=True, autoincrement=True)
CourseName = db.Column(db.String(255), unique=True)
Teachername = db.Column(db.String(255))
stuobject = db.Column(db.String(255))
CourseWeek = db.Column(db.String(255)) #课程学时
CourseDay = db.Column(db.String(255)) #课程周序
CourseTime = db.Column(db.String(255)) #课程节次
CoursePlace = db.Column(db.String(255)) #课程地点
School = db.Column(db.String(255))
def __init__(self, CourseName, Teachername, stuobject, CourseWeek,
CourseDay, CourseTime, CoursePlace, School):
self.CourseName = CourseName
self.Teachername = Teachername
self.stuobject = stuobject
self.CourseWeek = CourseWeek
self.CourseDay = CourseDay
self.CourseTime = CourseTime
self.CoursePlace = CoursePlace
self.School = School
def to_json(self):
json_data = {
'CourseId': self.CourseId,
'CourseName': self.CourseName,
'TeacherName': self.Teachername,
'stuobject': self.stuobject,
'CourseWeek': self.CourseWeek,
'CourseDay': self.CourseDay,
'CourseTime': self.CourseTime,
'CoursePlace': self.CoursePlace,
'School': self.School
}
return json.dumps(json_data)
class DictionaryDetail(db.Model):
__tablename__ = 'DictionaryDetail'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
DictionaryID = db.Column(db.Integer, db.ForeignKey('Dictionary.id'))
ItemValue = db.Column(db.String(32), nullable=False)
position = db.Column(db.Integer, nullable=False)
isDefault = db.Column(db.Integer, nullable=False)
def __init__(self, DictionaryID, ItemValue, position, isDefault):
self.DictionaryID = DictionaryID
self.ItemValue = ItemValue
self.position = position
self.isDefault = isDefault
def to_json(self):
json_data = {
'id': self.id,
'DictionaryID': self.DictionaryID,
'ItemValue': self.ItemValue,
'position': self.position,
'isDefault': self.isDefault
}
return json.dumps(json_data)
class Course(db.Model):
__tablename__ = 'Course'
CourseId = db.Column(db.Integer, primary_key=True, autoincrement=True)
CourseName = db.Column(db.String(255), unique=True)
TeachId = db.Column(db.Integer, db.ForeignKey('Teacher.TeachId'))
CourseWeek = db.Column(db.String(255)) #课程学时
CourseDay = db.Column(db.String(255)) #课程周序
CourseTime = db.Column(db.String(255)) #课程节次
CoursePlace = db.Column(db.String(255)) #课程地点
Layout = db.Column(db.String(255)) #课程布局
def __init__(self, CourseName, TeachId, CourseWeek, CourseDay, CourseTime,
CoursePlace, Layout):
self.CourseName = CourseName
self.TeachId = TeachId
self.CourseWeek = CourseWeek
self.CourseDay = CourseDay
self.CourseTime = CourseTime
self.CoursePlace = CoursePlace
self.Layout = Layout
def to_json(self):
TeacherName, TeachNumber = Teacher.query.filter_by(
TeachId=self.TeachId).first().get_TeachName_TeachNumber()
json_data = {
'CourseId': self.CourseId,
'CourseName': self.CourseName,
'TeachNumber': TeachNumber,
'TeacherName': TeacherName,
'CourseWeek': self.CourseWeek,
'CourseDay': self.CourseDay,
'CourseTime': self.CourseTime,
'CoursePlace': self.CoursePlace,
'Layout': self.Layout
}
return json.dumps(json_data)
class User(db.Model):
"""docstring for ClassName"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(255))
loginname = db.Column(db.String(255), nullable=True)
password = db.Column(db.String(255), nullable=True)
telphone = db.Column(db.String(255))
userdetail = db.Column(db.String(255))
lastlogin = db.Column(db.DateTime)
company = db.Column(db.String(255))
def __init__(self, loginname, password, userdetail, lastlogin):
super(User, self).__init__()
self.loginname = loginname
self.password = password
self.userdetail = userdetail
self.lastlogin = lastlogin
# self.company = company
# self.telphone = telphone
# 密码加密
def hash_password(self, password):
self.password = custom_app_context.encrypt(password)
# 密码解析
def verify_password(self, password):
return custom_app_context.verify(password, self.password)
# 获取token，有效时间10min
def generate_auth_token(self, expiration=60 * 60 * 24 * 15):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
# 解析token，确认登录的用户身份
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
#print(data)
except SignatureExpired: # valid token, but expired
print("valid token, but expired")
return None
# tokenRedis = redis.get(g.user.id)
# if tokenRedis is None: # get from redis
# raise AuthFailed(msg='token过期')
# else:
# token = g.user.generate_auth_token()
# redis.set(g.user.id, token)
# redis.expire(g.user.id, app.config['Expiration']*2)
# return g.user
except BadSignature:
return None
# raise AuthFailed(msg='token不正确') # invalid token
user = User.query.get(data['id'])
return user
def to_json(self):
json_data = {
'id': self.id,
'username': self.username,
'loginname': self.loginname,
'password': self.password,
'telphone': self.telphone,
'userdetail': self.userdetail,
'lastlogin': str(self.lastlogin),
'company': self.company
}
return json_data
