def burse_balance():
token = request.args.get('token', None)
print(token)
if token:
user_id = cache.get_token_user_id(token)
print(user_id)
vip_fee = request.args.get('vip_fee')
burse_balance = UserDao().get_burse(user_id)[0]['u_burse_balance']
print(burse_balance)
if burse_balance:
if int(vip_fee) > int(burse_balance):
api_logger.warning("余额不足")
return jsonify({
"code":207,
'msg':'您的余额不足!'
})
else:
burse_balance = int(burse_balance) - int(vip_fee)
UserDao().burse_change(user_id,burse_balance)
api_logger.info("充值成功")
return jsonify({
'code':200,
'msg':'恭喜您，您已成功充值会员!'
})
else:
api_logger.warning("余额为0")
return jsonify("您还没有余额，请充值")
else:
api_logger.info("user_id为空")
return jsonify('查无此用户')
def user_register(self, user_info):
"""
用户注册
:param user_info:
:return:
"""
email = user_info.get('email')
code = user_info.get('code')
real_code = redis_client.get(email)
# 校验注册码
if code != real_code:
raise Exception('register code is incorrect')
username = user_info.get('username')
user = UserDao.get_user_by_username(username)
if user:
raise Exception('user has existed')
salt = ''.join(str(uuid.uuid4()).split('-'))[:4]
password = hashlib.md5(user_info.get('password') + salt).hexdigest()
user = User.create(username, password, salt)
try:
UserDao.insert(user)
# 邮箱绑定到用户
email = Email.create(user.id, email)
EmailDao.insert(email)
db.session.commit()
except Exception as e:
db.session.rollback()
FaceAuthUtils.save_exception(traceback.format_exc())
raise Exception(e.message)
def send_msg_v1(self, user_id, eid, content):
"""
发送消息
:param user_id:
:param eid:
:param content:
:return:
"""
try:
user = UserDao.get_user_by_user_id(user_id)
add_emails = []
if user.role == User.Role.MANAGER:
# 发消息人是管理员, 给所有人发送
users = UserDao.get_all_users()
for user_ in users:
email = self.send_msg(user_id, '系统管理员', user_.id, content)
add_emails.append(email)
elif user.role == User.Role.STUDENT:
# 发消息人是老师, 给当前选实验的人发送
students = UserDao.get_all_student()
for student in students:
join_list = json.loads(student.join_experiments)
if eid in join_list:
# 当前用户选修了该实验
email = self.send_msg(user_id, user.username,
student.id, content)
add_emails.append(email)
db.session.bulk_save_objects(add_emails)
db.session.commit()
except Exception as e:
db.session.rollback()
raise Exception(str(e))
def make_employee_to_deliver(self, user_id, employee_name, order_number):
manager_user = UserDao.get_user_by_user_id(user_id)
if manager_user.identity_type != User.IdentityType.MANAGER:
raise Exception('你没有权限操作')
employee = UserDao.get_deliver_by_real_name(employee_name)
if not employee:
raise Exception('不存在该姓名的快递员')
# 进行指派
logistics = LogisticsDao.query_logistic_by_logistic_order_number(
order_number)
if not logistics:
raise Exception('不存在该物流信息')
if logistics.status != Logistics.Status.ARRAY_SITE:
raise Exception('该订单不满足配送条件')
try:
# 修改状态
logistics.status = Logistics.Status.DELIVERING
contents = json.loads(logistics.contents).get('data')
contents.append({
'content':
datetime.now().strftime('%Y-%m-%d %H:%M:%S') +
'包裹正在配送中, 配送员:%s, 联系电话:%s' %
(employee.real_name, employee.telephone)
})
logistics.contents = json.dumps({'data': contents})
logistics.user_id = employee.id
db.session.commit()
except Exception as e:
db.session.rollback()
raise Exception('指派过程出现异常, 错误信息:%s' % str(e))
def login_str():
try:
phone = request.form.get('phone')
auth_str = request.form.get('auth_str')
dao = UserDao()
if dao.check_login_name(phone): # 检测用户名是否存在
if dao.login_str(phone, auth_str): # 检测密码是否正确
token = cache.new_token()
user_id = dao.find_userid(phone)
save_token(token, user_id)
return jsonify({
'code': 200,
'msg': 'ok',
'token': token,
})
return jsonify({
'code': 406,
'msg': '用户名或密码输入错误',
})
except:
return jsonify({
"code": 400,
"msg": "注册登录失败"
})
def post(self):
json = request.get_json()
p_num = json.get("p_num")
token = json.get("token", "")
if check_token(token):
return jsonify({"code": 207, "msg": "已登录，不要重复登录!"})
password = str(json.get("password"))
dao = UserDao()
password = dao.make_pwd(password)
data = dao.tn_list(p_num, password)
if data == 2:
return jsonify({"code": 202, "msg": "密码错误!"})
elif data == 3:
return jsonify({"code": 203, "msg": "用户名不存在!"})
elif data == 4:
return jsonify({"code": 204, "msg": "该用户已经被封了!"})
else:
phone = data["p_num"]
token = uuid.uuid4().hex # token 需要转换为字符串
save_token(token, p_num)
return jsonify({
"code": 201,
"msg": 'ok',
"token": token,
"p_num": phone
})
def login_msg():
api_logger.debug('user phone_login get action!')
resp = eval(request.get_data())
if resp:
u_phone = resp.get('u_phone')
msg_code = resp.get('msg_code')
if all((bool(u_phone), bool(msg_code))):
udao = UserDao()
login_user = udao.login_msg(u_phone, msg_code)
# 检查验证码并检查手机号，如果存在，且验证码正确，则登录，否则注册
if login_user.get('id'): # 验证码正确
token = cache.new_token()
cache.save_token(token, login_user.get('id'))
udao.user_update('is_active', 1, 'u_phone', u_phone)
# PhoneDao().save(**{'phone': u_phone, 'code': msg_code, 'send_type': '登录'})
return jsonify({'code': 200,
'token': token,
'user_data': login_user
})
return jsonify(login_user)
else:
return jsonify({
'code': 101,
'msg': '请求参数u_phone和msg_code必须存在'
})
return jsonify({'code': 304, 'msg': '传入数据为空'})
def code_login():
r_data = request.get_json()
if r_data:
phone = r_data['phone']
pwd = r_data['pwd']
#判断接受的数据是否为空
if all((phone, pwd)):
u_password = UserDao().get_pwd('u_tel',phone)
if check_password(pwd,u_password):
user_id = UserDao().get_id('u_tel',phone)
print(user_id)
if user_id is not None:
token = uuid.uuid4().hex
save_token(token, user_id)
data = UserDao().get_profile(user_id)
return jsonify({
'code': 200,
'msg': '登录成功，欢迎使用MT外卖品台',
'token': token,
'data': data
})
return jsonify({
"code": 207,
"msg": "手机号或者密码错误,请重新输入"
})
def user_identify():
# 添加银行卡和身份证
u_data = request.get_json()
token = u_data.get('token')
if check_token(token):
dao = UserDao()
user_id = get_token_user_id(token)
print(user_id)
data = dao.check_real(user_id)
print(data)
if data:
u_bank = data[0]['u_bank']
user_card = data[0]['user_card']
if (u_bank and user_card) is not None:
return jsonify({'code': 300, 'msg': '您已添加过该信息！'})
else:
dict1 = {
'u_bank': u_data.get('u_bank'),
'user_card': u_data.get('user_card'),
'is_val': 1,
'asset': 0
}
for k, v in dict1.items():
user_save = dao.update('jd_user', k, v, 'user_id', user_id)
if user_save:
return jsonify({'code': 200, 'msg': '验证通过！'})
else:
return jsonify({'code': 400, 'msg': '添加失败！'})
else:
return jsonify({'code': 400, 'msg': '数据库查询失败！'})
else:
return jsonify({'code': 400, 'msg': 'token验证失败！'})
def user_regist():
# 前端请求的Content-Type: application/json
req_data = None
if request.headers['Content-Type'].startswith('application/json'):
req_data = request.get_json()
if req_data is None:
api_logger.warn('%s 请求参数未上传-json' % request.remote_addr)
return jsonify({'code': 9000, 'msg': '请上传json数据，且参数必须按api接口标准给定'})
api_logger.debug(req_data)
# 验证上传的必须的数据是否存在
if all((req_data.get('login_name',
False), req_data.get('login_auth_str', False))):
req_data['create_time'] = datetime.now().strftime('%Y-%m-%d')
req_data['update_time'] = req_data['create_time']
req_data['activated'] = 1 # 默认激活
dao = UserDao()
if dao.check_login_name(req_data.get('login_name')):
if dao.save(**req_data):
return jsonify({'code': 200, 'msg': 'ok'})
return jsonify({'code': 300, 'msg': '插入数据失败, 可能存在某一些字段没有给定值'})
else:
return jsonify({'code': 201, 'msg': '用户名已存在，不能再注册'})
def post(self):
args = parser.parse_args()
token = args.get("token")
if token:
return jsonify({
"status": 204,
"msg": "已登录，不要重复登录!",
})
p_num = args.get("p_num")
password = args.get("password")
dao = UserDao()
result = dao.tn_list(p_num, password)
if result == 1:
token = str(uuid.uuid4()) # token 需要转换为字符串
# key: 使用token 值:用户id
cache.set(token, p_num, timeout=60)
return jsonify({"status": 201, "msg": 'ok', "token": token})
elif result == 2:
return jsonify({
"status": 202,
"msg": "密码错误!",
})
elif result == 3:
return jsonify({
"status": 203,
"msg": "用户名不存在!",
})
def post(self):
json = request.get_json()
dao = OrderDao()
peo_count = json.get("peo_count")
child_count = json.get("child_count")
scenicid = json.get("scenicid")
date = request.form.get("date")
price = request.form.get("price")
order_time = datetime.now()
username = json.get("username")
phone_num = json.get("phone_num")
email = json.get("email")
token = json.get("token")
p_num = r.get(token)
user_dao = UserDao()
user_id = user_dao.user_id_list(p_num)
todao = TeOrderDao()
order_code = todao.next_order_num()
try:
dao.save("travel_infor", **{
"code":order_code,
"order_status":0,
"start_time":date,
"order_time":order_time,
"price":price,
"scenic_id":scenicid,
"user_id": user_id
})
dao.save("contact_infor",**{
"name":username,
"phone_num":phone_num,
"email":email,
"user_id":user_id
})
order_id = dao.order_list(order_code)
dao.save("order_detail", **{
"adult_num": peo_count,
"child_num": child_count,
"flight_id": 1,
"insurance": 1,
"order_id":order_id
})
return jsonify({
"code": 703,
"msg": "成功！"
})
except:
return jsonify({
"code": 704,
"msg": "保存失败！"
})
def post(self):
json = request.get_json()
p_num = json["p_num"]
dao = UserDao()
res = dao.p_list(p_num)
if res:
send_msg(p_num)
return jsonify({"code": 208, "msg": "发送成功！"})
else:
return jsonify({"code": 203, "msg": "用户名不存在！"})
def post(self):
json = request.get_json()
p_num = json["p_num"]
dao = UserDao()
res = dao.p_list(p_num)
if not res:
send_msg(p_num)
return jsonify({"code": 206, "msg": "ok！"})
else:
return jsonify({"code": 210, "msg": "手机号已存在，不能注册!"})
def change_tel():
r_data = request.get_json()
if r_data:
token = r_data['token']
user_id = get_token_user_id(token)
phone = r_data['phone']
if len(phone)== 11:
if UserDao().check_phone(phone):
if UserDao().set_userinfo('u_tel',phone,'id',user_id):
return jsonify({'code':200,'msg':'手机号修改成功','u_tel':phone})
return jsonify({'code':207,'msg':'手机号认证失败，请重新输入！'})
def pat_list(): # 获取患者列表
try:
token = request.args.get('token')
if not token:
return jsonify({"code": 400, "msg": "您还未登录,请先登录!"})
user_id = get_token_user_id(token) # 通过token获取id
dao = UserDao()
pat = dao.patient_list(user_id)
return jsonify({"code": 200, "msg": "获取患者列表成功！", "data": pat})
except:
return jsonify({'code': 400, 'msg': '暂无数据'})
def get_all_experiments(self, user_id):
"""
根据user_id的身份获取所有实验
:param user_id:
:return:
"""
user = UserDao.get_user_by_user_id(user_id)
experiments = []
if user.role == User.Role.MANAGER:
# 管理员可见所有
experiments = ExperimentDao.get_all_experiments()
elif user.role == User.Role.TEACHER:
# 老师仅可见自己的
experiments = ExperimentDao.get_experiments_by_teacher_id(user_id)
elif user.role == User.Role.STUDENT:
# 学生仅可见审批通过的
experiments = ExperimentDao.get_experiments_by_status(
Experiment.Status.SUCCESS)
lab_ids = [_.lab_no for _ in experiments]
laboratories = LaboratoryDao.get_lab_by_ids(lab_ids)
lab_no2name = {_.id: _.name for _ in laboratories}
res = []
for experiment in experiments:
# 查询所有选择该实验的学生
students = UserDao.get_all_student()
all_select_names = []
for student in students:
join_list = json.loads(student.join_experiments)
if experiment.id in join_list:
all_select_names.append(student.username)
teacher_name = UserDao.get_user_by_user_id(
experiment.teacher_id).username
res.append({
'id':
experiment.id,
'name':
experiment.name,
'start_time':
experiment.start_time.strftime('%Y-%m-%d %H:%M:%S'),
'end_time':
experiment.end_time.strftime('%Y-%m-%d %H:%M:%S'),
'remark':
experiment.remark,
'lab_name':
lab_no2name.get(experiment.lab_no, '未知'),
'teacher_name':
teacher_name,
'status':
Experiment.Status.__label__.get(experiment.status, '未知'),
'all_selects':
all_select_names
})
return res
def change_user():
r_data = request.get_json()
if r_data:
token = r_data['token']
user_id = get_token_user_id(token)
user_name = r_data['user_name']
if UserDao().check_username('user_name'):
if UserDao().set_userinfo('u_username', user_name, 'id', user_id):
return jsonify({'code': 200, 'msg': '用户名修改成功', 'u_username': user_name})
return jsonify({'code': 207, 'msg': '用户名修改失败'})
return jsonify({'code': 207, 'msg': '用户名已存在'})
return jsonify({'code':207,'msg':'请输入正确的参数'})
def upload_avator():
# 上传的头像字段为 img
# 表单参数： token
file: FileStorage = request.files.get('img', None)
token = request.form.get('token', None)
if all((bool(file), bool(token))):
# 验证文件的类型, png/jpeg/jpg, 单张不能超过2M
# content-type: image/png, image/jpeg
print(file.content_length, 'bytes')
if file.content_type in ('image/png',
'image/jpeg'):
filename = uuid.uuid4().hex \
+ os.path.splitext(file.filename)[-1]
file.save(filename)
# 上传到oss云服务器上
key = oss.upload_file(filename)
os.remove(filename) # 删除临时文件
# 将key写入到DB中
resp = request.get_json()
token = resp.get('token', None)
user_id = get_token_user_id(token)
u_dao = UserDao()
user_id = u_dao.get_profile(user_id)
if user_id:
pass
# if udao.check_login_phone(u_phone):
# login_user = udao.login_msg(u_phone, msg_code) # 检查验证码
# if login_user.get('id'):
# token = cache.new_token()
# cache.save_token(token, id)
# udao.user_update('u_auth_string', u_auth_string, 'u_phone', u_phone) # 更新密码
# udao.user_update('is_active', 1, 'u_phone', u_phone) # 更新状态
return jsonify({
'code': 200,
'msg': '上传文件成功',
'file_key': key
})
else:
return jsonify({
'code': 201,
'msg': '图片格式只支持png或jpeg'
})
return jsonify({
'code': 100,
'msg': 'POST请求参数必须有img和token'
})
def update_ph():
try:
dao = UserDao()
phone = request.form.get('phone')
data = dao.update_phone(phone)
return jsonify({
"code": 200,
"data": data
})
except:
return jsonify({
"code":400,
"msg":"发送失败"
})
def forget_pwd():
try:
phone = request.form.get('phone')
dao = UserDao()
data = dao.forget_pwd(phone)
return jsonify({
"code": 200,
"data": data
})
except:
return jsonify({
"code":400,
"msg":"未知错误"
})
def forgot_pwd():
api_logger.debug('user forget get action!')
resp = eval(request.get_data())
if resp:
u_phone = resp.get('phone')
msg_code = resp.get('msg')
u_auth_string = resp.get('auth_string')
if all((bool(u_phone), bool(msg_code), bool(u_auth_string))):
udao = UserDao()
# 验证手机号在数据库中是否存在
if udao.check_login_phone(u_phone):
login_user = udao.login_msg(u_phone, msg_code) # 检查验证码
if login_user.get('id'):
token = cache.new_token()
cache.save_token(token, id)
udao.user_update('u_auth_string', u_auth_string, 'u_phone', u_phone) # 更新密码
udao.user_update('is_active', 1, 'u_phone', u_phone) # 更新状态
# PhoneDao().save(**{'phone': u_phone, 'code': msg_code, 'send_type': '登录', })
return jsonify({'code': 200, 'token': token, 'user_data': login_user})
return jsonify(login_user)
else: # 手机号码不存在，提示
return jsonify({'code': 300, 'msg': '请填写注册手机号'})
else:
return jsonify({
'code': 101,
'msg': '请求参数u_phone,msg_code,u_auth_string必须存在'
})
return jsonify({'code': 304, 'msg': '传入数据为空'})
def get_all_experiments_pass(self, user_id):
"""
根据user_id的身份获取所有实验
:param user_id:
:return:
"""
user = UserDao.get_user_by_user_id(user_id)
if user.role != User.Role.TEACHER:
raise Exception("仅有老师有权限")
experiments = ExperimentDao.get_experiments_by_teacher_id_pass(user_id)
lab_ids = [_.lab_no for _ in experiments]
laboratories = LaboratoryDao.get_lab_by_ids(lab_ids)
lab_no2name = {_.id: _.name for _ in laboratories}
res = []
for experiment in experiments:
# 查询所有选择该实验的学生
students = UserDao.get_all_student()
all_select_names = []
for student in students:
join_list = json.loads(student.join_experiments)
if experiment.id in join_list:
all_select_names.append(student.username)
teacher_name = UserDao.get_user_by_user_id(
experiment.teacher_id).username
res.append({
'id':
experiment.id,
'name':
experiment.name,
'start_time':
experiment.start_time.strftime('%Y-%m-%d %H:%M:%S'),
'end_time':
experiment.end_time.strftime('%Y-%m-%d %H:%M:%S'),
'remark':
experiment.remark,
'lab_name':
lab_no2name.get(experiment.lab_no, '未知'),
'teacher_name':
teacher_name,
'status':
Experiment.Status.__label__.get(experiment.status, '未知'),
'all_selects':
all_select_names
})
return res
def delete_user(self, user_id, username):
"""
删除用户
"""
try:
manager_user = UserDao.get_user_by_user_id(user_id)
if manager_user.identity_type != User.IdentityType.MANAGER:
raise Exception('你没有权限操作')
user = UserDao.get_user_by_username(username)
if not user:
raise Exception('用户不存在')
user.status = User.Status.ABANDON
db.session.commit()
except Exception as e:
db.session.rollback()
raise e
def update_experiment(self, user_id, eid, status):
"""
修改实验状态
:param status:
:param user_id:
:param eid:
:return:
"""
user = UserDao.get_user_by_user_id(user_id)
if user.role != User.Role.MANAGER:
raise Exception("只有管理员可以审批")
experiment = ExperimentDao.get_experiment_by_id(eid)
if not experiment:
raise Exception("不存在该计划")
try:
experiment.status = status
content = ''
if status == Experiment.Status.SUCCESS:
content = '您的实验:%s, 已经审批通过。' % experiment.name
elif status == Experiment.Status.FAILED:
content = '您的实验:%s, 审批未通过, 请联系系统管理员重新申请。' % experiment.name
email = email_service.send_msg(user_id, u'系统管理员',
experiment.teacher_id, content)
db.session.add(email)
db.session.commit()
except Exception as e:
db.session.rollback()
raise Exception(str(e))
def user_increase(self, user_id, username):
"""
用户变为快递员
"""
try:
manager_user = UserDao.get_user_by_user_id(user_id)
if manager_user.identity_type != User.IdentityType.MANAGER:
raise Exception('你没有权限操作')
user = UserDao.get_user_by_username(username)
if not user:
raise Exception('用户不存在')
user.identity_type = User.IdentityType.COURIER
db.session.commit()
except Exception as e:
db.session.rollback()
raise e
def get_face_by_user_id(self, user_id, filters, page=1):
"""
根据用户id查询其下人脸信息
:param
:return:
"""
faces, total = FaceDao.get_face_by_user_id(user_id, page, filters)
if not faces:
return {'data': [], 'total': 0}
user = UserDao.get_user_by_user_id(user_id)
res = {}
data = []
for face in faces:
data.append({
'id': face.id,
'name': face.face_name,
'belong': user.username,
'url': face.face_url,
'status': face.status,
'stu_class': face.face_class,
'open_check': face.open_check
})
res.update({
'data': data,
'total': total
})
return res
def upload_head():
# 上传文件的头像字段 img
# 表单参数token
file = request.files.get('img',None)
token = request.form.get('token',None)
if all((bool(file),bool(token))):
# 验证图片类型
print(type(file))
if file.content_type in ('image/png','image/jpeg'):
filename = uuid.uuid4().hex+os.path.splitext(file.filename)[-1]
file.save(filename)
# 上传到云服务器
file_key = oss.upload_file(filename)
os.remove(filename)
user_id = get_token_user_id(token)
UserDao().set_userinfo(key='u_headpic',value=file_key,where='id',args=user_id)
img_url = oss.get_url(file_key)
return jsonify({
'code':200,
'msg':'头像上传成功',
'img':img_url
})
else:
return jsonify({
'code': 207,
'msg': '图片只支持png和jpeg'
})
else:
return jsonify({
'code':207,
'msg':'POST参数必须有img和token'
})
def post(self):
json = request.get_json()
p_num = json.get("p_num")
vzm = json.get("vzm")
local_vzm = r.get("TN" + p_num).decode()
if local_vzm == vzm:
password = str(json.get("password"))
dao = UserDao()
password = dao.make_pwd(password)
dao.update_pwd(password)
return jsonify({"code": 211, "msg": "更改成功!"})
else:
return jsonify({"code": 205, "msg": "验证码错误!"})
def post(self):
json = request.get_json()
p_num = json.get("p_num")
vzm = json.get("vzm")
local_vzm = r.get("TN" + p_num).decode()
if int(local_vzm) == vzm:
password = str(json.get("password"))
dao = UserDao()
password = dao.make_pwd(password)
dao.save(**{"p_num": p_num, "password": password, "is_active": 1})
return jsonify({"code": 209, "msg": "注册成功!"})
else:
return jsonify({"code": 205, "msg": "验证码错误!"})
def get_public_accounts():
#db_handler = DBManager.get_connection()
#cursor = db_handler['user'].find(projection=['_id','name'])
#accounts = JsonUtil.listToStr(cursor)
accounts = UserDao.get_users();
#accounts = json.dumps(cursor)
return jsonify({'accounts': accounts})
def get_accounts():
#db_handler = DBManager.get_connection()
#cursor = db_handler['user'].find(projection={'password':False})
#accounts = JsonUtil.listToStr(cursor)
accounts = UserDao.get_users();
#accounts = json.dumps(cursor)
json_resp = jsonify({'accounts': JSONEncoder().encode(accounts)})
res = make_response(json_resp, 200)
res.headers['Content-Type'] = 'text/json; charset=utf-8'
return res
def test_get_account_by_id(self):
oid = u'56840a2db37b6c16a0ef1b6c'
user = UserDao.get_user_by_id(oid)
#logger.debug('test_get_account_by_id type={0}'.format(type(user['name'])))
expected_user_name = u'anna'
self.assertEquals(user['name'],expected_user_name,'signed user name should be {0}'.format(expected_user_name))
def get_api_token(self, access_token):
return UserDao.get_api_token(access_token)
def get_token(self, email, hashed_pwd):
return UserDao.get_token(email, hashed_pwd)
def create_token(self, email, hashed_pwd):
return UserDao.create_token(email, hashed_pwd)
def check_token(self, token):
if token is None:
return False
else:
return UserDao.checkToken(token)
def create_user(self, email, pwd, token):
UserDao.create_user(email, pwd, token)
def test_get_users(self):
users = UserDao.get_users()
logger.debug('test_get_users size={0}'.format(type(users)))
expected_size = 3
self.assertEquals(len(users),expected_size,'number of users should be {0}'.format(expected_size))
