def reg():
if request.method == "GET":
return render_template('register.html')
if request.method == "POST":
"""
用户注册
:return: json
"""
email = request.form.get('email')
username = request.form.get('username')
password = request.form.get('password')
user = User(email=email,
username=username,
password=utils.set_password(password))
result = User.add(User, user)
if user.userid:
returnUser = {
'id': user.userid,
'username': user.username,
'email': user.email,
'login_time': user.login_time
}
return jsonify(utils.trueReturn(returnUser, "用户注册成功"))
# success = utils.trueReturn(returnUser, "用户注册成功")
# return render_template('register.html',**success)
else:
return jsonify(utils.falseReturn('', '用户注册失败'))
def updateuserstate(request):
result = {}
user_receive = User()
if request.method == "POST":
userid = request.POST.get("userid", None) # 读取get数据，None为默认值
qunid = request.POST.get("qunid", None) # 读取get数据，None为默认值
userstate = request.POST.get("userstate", None) # 读取get数据，None为默认值
if request.method == "GET":
userid = request.GET.get("userid", None) # 读取get数据，None为默认值
qunid = request.GET.get("qunid", None) # 读取get数据，None为默认值
userstate = request.GET.get("userstate", None) # 读取get数据，None为默认值
print("修改用户在群组中的状态接口参数：用户id" + userid +"用户状态" + userstate)
user_receive = UserDAO.getUserInfoId(userid)
user_receive.state(userstate)
UserDAO.updateUserInfo(user_receive)
qun = QunDAO.getqunInfoqunid(qunid)
userqun=Userqun()
userqun.userid=userid
userqun.qunid=qunid
userqun = UserqunDAO.getuserqunInfouserqun(userqun)
if(not userqun or not qun):
result["data"]=""
result["respcode"]= ResultCode.FAIL
result["errorcode"]=ResultCode.FAIL
result["message"]= "修改失败not "
return result
userqun.userstate=userstate
UserqunDAO.updateuserqun(userqun)
#如果升级为群主
if(userstate==ResultCode.USERQUN_QUNZHU):
#查找原群主关系组
userqun.userid=qun.userid
userqun.qunid=qunid
userqun = UserqunDAO.getuserqunInfouserqun(userqun)
userqun.userstate=ResultCode.USERQUN_FUZHU
UserqunDAO.updateuserqun(userqun)
#修改群信息
qun.userid=userid
QunDAO.updatequnInfoqun(qun)
result["data"]= ""
result["respcode"]= ResultCode.SUCCESS
result["errorcode"]= ""
result["message"]= "修改成功not "
return result
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('Congratulations, you are now a registered user!')
return redirect(url_for('login'))
return render_template('register.html', title='Register', form=form)
def uploadUserIcon(request):
result = {}
user = User()
if request.method == "POST":
id = request.POST.get("id", None) # 读取get数据，None为默认值
if request.method == "GET":
id = request.GET.get("id", None) # 读取get数据，None为默认值
print("修改图像接口参数：用户id:", id)
realPath = STATICFILES_DIRS[0] + "/upload/userIcon/"
# realPath = request.getSession().getServletContext().getRealPath("userIcon/")
if not os.path.exists(realPath):
os.makedirs(realPath)
try:
files = request.FILES.getlist('files')
multFile = files[0]
filenameString = id + "_" + str(int(
time.time())) + "_" + str(0) + ".png"
filepath = realPath + "/" + filenameString
f_obj = open(filepath, 'wb+')
for chunk in multFile.chunks():
f_obj.write(chunk)
f_obj.close()
fileName = STATIC_URL1 + "upload/userIcon/" + filenameString
print("用户图像所在地址:", realPath, "/", fileName)
user.image = fileName
user.id = id
UserDAO.updateUserIcon(user)
users_back = UserDAO.getUserInfoId(user.id)
usermeback = user2meBack(users_back)
result["data"] = usermeback
result["errorcode"] = ""
result["message"] = "上传用户图像成功"
result["respcode"] = ResultCode.SUCCESS
print('上传用户图像成功')
except Exception as e:
result["data"] = ""
result["errorcode"] = ResultCode.VINT
result["message"] = "文件不合法"
result["respcode"] = ResultCode.FAIL
print('文件不合法')
return JsonResponse(result)
def reg(req):
if req.method=='POST':
uf=uform(req.POST,req.FILES)
if uf.is_valid():
user=User()
user.username=uf.cleaned_data['username']
user.img=uf.cleaned_data['img']
user.save()
req.session['usr']=user.username
return HttpResponseRedirect(r'/success/')
else :
return render_to_response('register.html',{'f':uf})
else:
uf=uform()
return render_to_response('register.html',{'f':uf})
def reg_upload(request):
if request.method == 'POST':
if request.POST['password'] == request.POST['password1']:
reg = User(name=request.POST['name'],
username=request.POST['username'],
password=request.POST['password'])
reg.save()
return render(request, 'index.html')
else:
return HttpResponse(
"<script>alert('Password didnt match')</script>")
return redirect('/')
else:
return HttpResponse("<h1>Error While Registering.. TRy Again..</h1>")
def identify(self, request):
"""
用户鉴权
:return: list
"""
auth_header = request.headers.get('Authorization')
if (auth_header):
auth_tokenArr = auth_header.split(" ")
if (not auth_tokenArr or auth_tokenArr[0] != 'JWT' or len(auth_tokenArr) != 2):
result = utils.falseReturn('', '请传递正确的验证头信息')
else:
auth_token = auth_tokenArr[1]
payload = self.decode_auth_token(auth_token)
if not isinstance(payload, str):
user = User.get(Users, payload['data']['id'])
if (user is None):
result = utils.falseReturn('', '找不到该用户信息')
else:
if (user.login_time == payload['data']['login_time']):
result = utils.trueReturn(user.id, '请求成功')
else:
result = utils.falseReturn('', 'Token已更改，请重新登录获取')
else:
result = utils.falseReturn('', payload)
else:
result = utils.falseReturn('', '没有提供认证token')
return result
def post(request):
user = request.user.user
data = request.data
kicked_user_id =data['kicked_user_id']
kicked_user = User.get_object(pk=kicked_user_id)
if user.clanData.position <= kicked_user.clanData.position:
return Response({"detail": "can not kick this position"}, status=status.HTTP_406_NOT_ACCEPTABLE)
if user.userClan != kicked_user.userClan:
return Response({'detail': 'you are not in a same clan'}, status=status.HTTP_406_NOT_ACCEPTABLE)
else:
clan = kicked_user.userClan
RemoveUserFromGroup(clan.backtory_group_id, clan.backtory_group_owner, kicked_user.backtory_userId)
kicked_user.userClan = None
# TODO: update score and other things
kicked_user.clanData.donate_count = 0
kicked_user.clanData.lastRequestTime = 0
kicked_user.clanData.position = 0
kicked_user.clanData.save()
kicked_user.save()
# backtory push msg
news_obj = NewsMessageWrapper({'kicked_user_id': kicked_user.idUser, 'kicked_username': kicked_user.username},
NewsType.user_kick)
msg_obj = MessageWrapper(news_obj, MsgType.news)
PushMessageToGroup(json.dumps(msg_obj), clan.backtory_group_id)
return Response({}, status=status.HTTP_406_NOT_ACCEPTABLE)
def post(request):
user = request.user.user
clan = user.userClan
data = request.data
accepted_user_id = data['accepted_user_id']
waiting_list = dict(clan.waiting_list)
if user.clanData.position == 0:
return Response({'detail': 'member user can not accept users'}, status=status.HTTP_406_NOT_ACCEPTABLE)
if accepted_user_id in waiting_list:
del waiting_list[accepted_user_id]
clan.waiting_list = waiting_list
clan.save()
accepted_user = User.get_object(pk=int(accepted_user_id))
accepted_user.userClan = clan
if accepted_user.clanData is None:
clan_data = UserClanData.objects.create()
accepted_user.clanData = clan_data
accepted_user.clanData.position = 0
accepted_user.clanData.donate_count = 0
accepted_user.clanData.lastRequestTime = -1
accepted_user.clanData.save()
accepted_user.pending_clan_id = -1
accepted_user.pending_clan_name = None
accepted_user.save()
AddUserToGroup(clan.backtory_group_id, clan.backtory_group_owner, accepted_user.backtory_userId)
user_clan_info = serializer.ClanUserSerializer(accepted_user).data
# backtory push msg
news_obj = NewsMessageWrapper(user_clan_info, NewsType.user_accept)
msg_obj = MessageWrapper(news_obj, MsgType.news)
PushMessageToGroup(json.dumps(msg_obj), clan.backtory_group_id)
return Response({'accepted_user': user_clan_info}, status=status.HTTP_200_OK)
else:
return Response({'detail': 'accepted user does not exist in waiting list'}, status=status.HTTP_406_NOT_ACCEPTABLE)
def post(request):
user = request.user.user
data = request.data
demoted_user_id = int(data['userID'])
user_clan_data = user.clanData
demoted_user = User.get_object(pk=demoted_user_id)
if user.userClan != demoted_user.userClan:
return Response({'detail': 'your not in a same clan'}, status=status.HTTP_406_NOT_ACCEPTABLE)
if user_clan_data.position < 2:
return Response({'detail': 'your position in clan < co-leader'}, status=status.HTTP_406_NOT_ACCEPTABLE)
elif user_clan_data.position is 2:
if demoted_user.clanData.position != 1:
return Response({'detail': 'can not demote co leader and leader'}, status=status.HTTP_406_NOT_ACCEPTABLE)
demoted_user.clanData.position -= 1
elif user_clan_data.position is 3:
if demoted_user.clanData.position == 3 or demoted_user.clanData.position == 0:
return Response({'detail': 'can not demote leader in this way'}, status=status.HTTP_406_NOT_ACCEPTABLE)
demoted_user.clanData.position -= 1
demoted_user.clanData.save()
response_data = {
'demoted_userId': demoted_user_id,
'demoted_username': demoted_user.username,
'demoter_username': user.username,
'demoter_userId': user.idUser,
'demoted_new_position': demoted_user.clanData.position
}
# backtory push msg
clan = user.userClan
news_obj = NewsMessageWrapper(response_data, NewsType.user_demote)
msg_obj = MessageWrapper(news_obj, MsgType.news)
PushMessageToGroup(json.dumps(msg_obj), clan.backtory_group_id)
return Response(response_data, status=status.HTTP_200_OK)
def register(requests):
res = ''
if requests.method == "POST":
username = requests.POST.get("username")
pwd = requests.POST.get("password")
email = requests.POST.get("email")
#先检查是否存在该用户名
user_list = User.objects.filter(username=username)
if user_list:
#如果数据库中有该用户名的数据
res = '%s 该用户名已被注册过了' % username
return render(requests, 'register.html', {"res": res})
else:
#插入数据库,推荐写法：
user = User()
user.username = username
#明文
# user.password=pwd
#密文
user.password = make_password(pwd)
user.email = email
user.save()
#第二种写法
# user=User(username=username,password=pwd,email=email)
return render(requests, 'login.html', {"res": res})
else:
return render(requests, 'register.html')
def authenticate(self, username, password):
"""
用户登录，登录成功返回token，写将登录时间写入数据库；登录失败返回失败原因
:param password:
:return: json
"""
userInfo = User.query.filter_by(username=username).first()
if (userInfo is None):
return jsonify(utils.falseReturn('', '找不到用户'))
else:
if (utils.check_password(userInfo.password, password)):
login_time = int(time.time())
userInfo.login_time = login_time
User.update(User)
token = self.encode_auth_token(userInfo.userid, login_time)
return jsonify(utils.trueReturn(token.decode(), '登录成功'))
else:
return jsonify(utils.falseReturn('', '密码不正确'))
def add_user(request):
if request.method == 'GET':
code = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(9))
names = [
"David", "John", "Paul", "Mark", "Andrew", "Scott", "Steven",
"Robert", "Stephen", "William", "Craig", "Michael", "Stuart",
"Christopher", "Alan", "Colin", "Brian", "Kevin", "Gary",
"Richard", "Derek", "Martin", "Thomas", "Neil", "Barry", "Ian",
"Jason", "Iain"
]
real_name = random.choice(names)
timezones = [
"(GMT -12:00) Eniwetok, Kwajalein",
"(GMT -11:00) Midway Island, Samoa", "(GMT -10:00) Hawaii",
"(GMT -8:00) Pacific Time (US & Canada)",
"(GMT -6:00) Central Time (US & Canada), Mexico City",
"(GMT -5:00) Eastern Time (US & Canada), Bogota, Lima",
"(GMT -3:30) Newfoundland"
]
tz = random.choice(timezones)
min_year = 1900
max_year = datetime.now().year
start = datetime(min_year, 1, 1, 00, 00, 00)
years = max_year - min_year + 1
end = start + timedelta(days=365 * years)
start_time = start + (end - start) * random.random()
end_time = start + (end - start) * random.random()
user = User(no=code, real_name=real_name, tz=tz)
activity_period = Activity(no=code,
start_time=start_time,
end_time=end_time)
try:
user.save()
activity_period.save()
response = json.dumps([{'User added successfully! -': code}])
except:
response = json.dumps([{'Error': 'User could not be added!'}])
return HttpResponse(response, content_type='text/json')
def wechat_log(request):
itchat.login(picDir='')
#picDir = ''
user = itchat.get_friends()
# 取出user中的第一段(即用户本人)的信息
i = str(user[:1])
print(i)
info = i[8:-2]
print(info)
UserName = str(re.findall(r"'UserName': (.+?),", info))[2:-2]
NickName = str(re.findall(r"'NickName': '(.+?)'", info))[2:-2] # 昵称
sign = str(re.findall(r"'Signature': '(.+?)'", info))[2:-2] # 签名
sex = str(re.findall(r"'Sex': (.+?),", info))[2:-2] # 1男 0女
uin = str(re.findall(r"'Uin': (.+?),", info))[2:-2]
img = str(re.findall(r"'HeadImgUrl': (.+?),", info))[2:-2]
print(img)
print(UserName)
print(NickName)
print(sign)
print(sex)
print(uin)
username = uin
password = uin
qq = uin
email = uin
tel = uin
photo = img
new_user = User()
new_user.username = username
md5 = hashlib.md5()
md5.update(password.encode("utf-8"))
new_user.password = md5.hexdigest()
new_user.qq = qq
new_user.email = email
new_user.tel = tel
new_user.photo = photo
new_user.save()
request.session["user_id"] = user.id
return redirect(reverse("transaction:person_center"))
def verify_password(email_or_token, password):
print '####', email_or_token, password
if email_or_token == '':
return False
if password == '':
g.current_user = User.verify_auth_token(email_or_token)
g.token_used = True
return g.current_user is not None
user = User.query.filter_by(email=email_or_token).first()
if not user:
return False
g.current_user = user
g.token_used = False
return user.verify_password(password)
def post(request):
user = request.user.user
clan = user.userClan
data = request.data
if user.clanData.position == 0:
return Response({"detail": "this position can not invite user"}, status=status.HTTP_406_NOT_ACCEPTABLE)
invite_user_id = data['invite_user_id']
invite_user = User.get_object(pk=invite_user_id)
if not(user.userClan is None):
return Response({'detail': 'this user currently had joined in another clan'}, status=status.HTTP_406_NOT_ACCEPTABLE)
data = {'time': int(time.time()), 'clan_name': clan.clanName}
invite_user.invitaion_list[str(clan.idClan)] = json.dumps(data)
invite_user.save()
return Response({}, status=status.HTTP_406_NOT_ACCEPTABLE)
def signin():
if request.method == 'GET':
return render_template('signin.html')
if request.method == 'POST':
if db.session.query(User).filter(
User.username == request.form['user']).all():
return "account exist"
else:
db.session.add(
User(username=request.form['user'],
password=request.form['pwd'],
email=request.form['email']))
db.session.commit()
db.session.close()
return "register success"
def userget():
"""
获取用户信息
:return: json
"""
result = Auth.identify(Auth, request)
if (result['status'] and result['data']):
user = User.get(User, result['data'])
returnUser = {
'id': user.userid,
'username': user.username,
'email': user.email,
'login_time': user.login_time
}
result = utils.trueReturn(returnUser, "请求成功")
return jsonify(result)
def users(count=100):
fake = Faker()
i = 0
while i < count:
u = User(email=fake.email(),
username=fake.user_name(),
password='******',
confirmed=True,
name=fake.name(),
location=fake.city(),
about_me=fake.text(),
member_since=fake.past_date())
db.session.add(u)
try:
db.session.commit()
i += 1
except IntegrityError:
db.session.rollback()
def reg(req):
if req.method == 'POST':
uf = uform(req.POST, req.FILES)
if uf.is_valid():
user = User()
user.username = uf.cleaned_data['username']
user.img = uf.cleaned_data['img']
user.save()
req.session['usr'] = user.username
return HttpResponseRedirect(r'/success/')
else:
return render_to_response('register.html', {'f': uf})
else:
uf = uform()
return render_to_response('register.html', {'f': uf})
def regverify(request):
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
email = request.POST['email']
users = User.objects.all()
#注册验证
for user in users:
if user.username == username:
return render(request, 'chat/register.html', {'error': 1})
if username and email and password:
u1 = User()
u1.username = username
u1.email = email
u1.password = password
u1.createTime = datetime.datetime.now()
u1.save()
#redis
return render(request, 'chat/login.html', {})
else:
return render(request, 'chat/register.html', {'error': 2})
else:
return render(request, 'chat/login.html', {})
def regist(request):
if request.method == 'POST':
uf = registForm(request.POST)
if uf.is_valid():
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
password1 = uf.cleaned_data['password1']
if password != password1:
return render_to_response('error_2.html')
user = User.objects.filter(username=username)
if user:
return render_to_response('error_1.html')
if len(user) == 0:
info = '注册成功!'
user = User()
user.username = username
user.password = password
user.save()
return render_to_response('success.html')
else:
uf = UserForm()
return render_to_response('regist.html', {'uf': uf})
def test_password_verification(self):
u = User(password='******')
self.assertTrue(u.verify_password('cat'))
self.assertFalse(u.verify_password('dog'))
def test_password_salts_are_random(self):
u = User(password='******')
u2 = User(password='******')
self.assertTrue(u.password_hash != u2.password_hash)
def register(request):
#用户名username
#密码password
#qq
#email
#tel
#photo
if request.method == "GET":
return render(request, 'login_/register.html')
elif request.method == "POST":
username = request.POST.get("username") #接收用户名
password = request.POST.get("password") #
qq = request.POST.get("qq")
email = request.POST.get("email")
tel = request.POST.get("tel")
photo = request.FILES.get("photo") # 接收头像
new_user = User()
new_user.username = username
md5 = hashlib.md5()
md5.update(password.encode("utf-8"))
new_user.password = md5.hexdigest()
new_user.qq = qq
new_user.email = email
new_user.tel = tel
if photo:
new_user.photo = photo
else:
photo = '/uploads/morenphoto.jpg'
new_user.photo = photo
new_user.save()
return redirect(reverse("transaction:login_"))
def test_roles_and_permissions(self):
Role.insert_roles()
u = User(email='*****@*****.**', password='******')
self.assertTrue(u.can(Permission.WRITE))
self.assertFalse(u.can(Permission.MODERATE))
def login(request):
result = {}
user = User()
if request.method == "POST":
phone = request.POST.get("phone", None) # 读取get数据，None为默认值
password = request.POST.get("password", None) # 读取get数据，None为默认值
identity = request.POST.get("identity", None) # 读取get数据，None为默认值
school = request.POST.get("school", None) # 读取get数据，None为默认值
qunid = request.POST.get("qunid", 0) # 读取get数据，None为默认值
if request.method == "GET":
phone = request.GET.get("phone", None) # 读取get数据，None为默认值
password = request.GET.get("password", None) # 读取get数据，None为默认值
identity = request.GET.get("identity", None) # 读取get数据，None为默认值
school = request.GET.get("school", None) # 读取get数据，None为默认值
qunid = request.GET.get("qunid", 0) # 读取get数据，None为默认值
print("用户登录接口参数：电话", phone, "密码", password)
user.phone = phone
user.password = password
user = UserDAO.login(user)
if (user):
if (identity): user.identity = identity
if (school): user.school = school
UserDAO.updateUserInfo(user)
# 如果登陆时需要加入群组，这里加入群组
if (qunid):
try:
qun = QunDAO.getqunInfoqunid(qunid)
userqun = Userqun()
userqun.userid = user.id
userqun.qunid = qunid
userquntemp = UserqunDAO.getuserqunInfouserqun(userqun)
if (not userquntemp):
if (qun.quntype == ResultCode.QUN_USER
or qun.quntype == ResultCode.QUN_USER_DIARY or
qun.quntype == ResultCode.QUN_USER_DIARY_NOT_USER):
userqun.userstate = ResultCode.USERQUN_NOT
else:
userqun.userstate = ResultCode.USERQUN_YUAN
UserqunDAO.adduserqun(userqun)
# 添加群聊关系
chatuser = Chatuser()
chatuser.send_id = qunid
chatuser.receive_id = user.id
chatuser.usertype = ResultCode.CHATUSER_TYPE_QUN
chatuser.state = ResultCode.CHATUSER_HIDE
chatuser.abid = str(qunid)
chatuser.content = ""
chatuser.time = TimeUtil.getCurrentTime()
chatuser.date = TimeUtil.getCurrentDate()
ChatuserDAO.addchatuser(chatuser)
except Exception as e:
print(e)
user_me_back = user2meBack(user)
# appBean = AppVersionDAO.queryVersionById(1) # 这里要求数据库中首先在版本表中存在版本的相关信息
result["data"] = user_me_back
result["respcode"] = ResultCode.SUCCESS
result["errorcode"] = ""
result["message"] = "登陆成功"
print('登陆成功')
else:
result["data"] = ""
result["respcode"] = ResultCode.FAIL
result["errorcode"] = ResultCode.FAIL
result["message"] = "账号或密码错误"
print('账号密码错误')
return JsonResponse(result)
def userRegist(request):
user = User()
result = {}
if request.method == "POST":
phone = request.POST.get("phone", None) # 读取post数据，None为默认值
qunid = request.POST.get("qunid", 0) # 读取get数据，None为默认值
password = request.POST.get("password", None) # 读取post数据，None为默认值
name = request.POST.get("name", None) # 读取post数据，None为默认值
identity = request.POST.get("identity", None) # 读取post数据，None为默认值
email = request.POST.get("email", None) # 读取post数据，None为默认值
address = request.POST.get("address", None) # 读取post数据，None为默认值
school = request.POST.get("school", None) # 读取post数据，None为默认值
usertype = request.POST.get("usertype", 0) # 读取post数据，None为默认值
usericon = request.POST.get("usericon", None) # 读取get数据，None为默认值
wechat = request.POST.get("wechat", None) # 读取get数据，None为默认值
alipay = request.POST.get("alipay", None) # 读取get数据，None为默认值
parameter1 = request.POST.get("parameter1", None) # 读取get数据，None为默认值
parameter2 = request.POST.get("parameter2", None) # 读取get数据，None为默认值
parameter3 = request.POST.get("parameter3", None) # 读取get数据，None为默认值
parameter4 = request.POST.get("parameter4", None) # 读取get数据，None为默认值
parameter5 = request.POST.get("parameter5", None) # 读取get数据，None为默认值
parameter6 = request.POST.get("parameter6", None) # 读取get数据，None为默认值
parameter7 = request.POST.get("parameter7", None) # 读取get数据，None为默认值
parameter8 = request.POST.get("parameter8", None) # 读取get数据，None为默认值
parameter9 = request.POST.get("parameter9", None) # 读取get数据，None为默认值
parameter10 = request.POST.get("parameter10", None) # 读取get数据，None为默认值
parameter11 = request.POST.get("parameter11", None) # 读取get数据，None为默认值
parameter12 = request.POST.get("parameter12", None) # 读取get数据，None为默认值
parameter13 = request.POST.get("parameter13", None) # 读取get数据，None为默认值
parameter14 = request.POST.get("parameter14", None) # 读取get数据，None为默认值
parameter15 = request.POST.get("parameter15", None) # 读取get数据，None为默认值
parameter16 = request.POST.get("parameter16", None) # 读取get数据，None为默认值
parameter17 = request.POST.get("parameter17", None) # 读取get数据，None为默认值
parameter18 = request.POST.get("parameter18", None) # 读取get数据，None为默认值
parameter19 = request.POST.get("parameter19", None) # 读取get数据，None为默认值
parameter20 = request.POST.get("parameter20", None) # 读取get数据，None为默认值
if request.method == "GET":
phone = request.GET.get("phone", None) # 读取get数据，None为默认值
qunid = request.GET.get("qunid", 0) # 读取get数据，None为默认值
password = request.GET.get("password", None) # 读取get数据，None为默认值
name = request.GET.get("name", None) # 读取get数据，None为默认值
identity = request.GET.get("identity", None) # 读取get数据，None为默认值
email = request.GET.get("email", None) # 读取get数据，None为默认值
address = request.GET.get("address", None) # 读取get数据，None为默认值
school = request.GET.get("school", None) # 读取get数据，None为默认值
usertype = request.GET.get("usertype", 0) # 读取post数据，None为默认值
usericon = request.GET.get("usericon", None) # 读取get数据，None为默认值
wechat = request.GET.get("wechat", None) # 读取get数据，None为默认值
alipay = request.GET.get("alipay", None) # 读取get数据，None为默认值
parameter1 = request.GET.get("parameter1", None) # 读取get数据，None为默认值
parameter2 = request.GET.get("parameter2", None) # 读取get数据，None为默认值
parameter3 = request.GET.get("parameter3", None) # 读取get数据，None为默认值
parameter4 = request.GET.get("parameter4", None) # 读取get数据，None为默认值
parameter5 = request.GET.get("parameter5", None) # 读取get数据，None为默认值
parameter6 = request.GET.get("parameter6", None) # 读取get数据，None为默认值
parameter7 = request.GET.get("parameter7", None) # 读取get数据，None为默认值
parameter8 = request.GET.get("parameter8", None) # 读取get数据，None为默认值
parameter9 = request.GET.get("parameter9", None) # 读取get数据，None为默认值
parameter10 = request.GET.get("parameter10", None) # 读取get数据，None为默认值
parameter11 = request.GET.get("parameter11", None) # 读取get数据，None为默认值
parameter12 = request.GET.get("parameter12", None) # 读取get数据，None为默认值
parameter13 = request.GET.get("parameter13", None) # 读取get数据，None为默认值
parameter14 = request.GET.get("parameter14", None) # 读取get数据，None为默认值
parameter15 = request.GET.get("parameter15", None) # 读取get数据，None为默认值
parameter16 = request.GET.get("parameter16", None) # 读取get数据，None为默认值
parameter17 = request.GET.get("parameter17", None) # 读取get数据，None为默认值
parameter18 = request.GET.get("parameter18", None) # 读取get数据，None为默认值
parameter19 = request.GET.get("parameter19", None) # 读取get数据，None为默认值
parameter20 = request.GET.get("parameter20", None) # 读取get数据，None为默认值
print("注册用户接口参数：电话", phone, "密码", password, "名称:", name)
if (not phone or not password):
result["data"] = ""
result["respcode"] = ResultCode.FAIL
result["errorcode"] = ResultCode.FAIL
result["message"] = "注册失败，电话密码不能为空"
print("注册失败，电话密码不能为空")
return JsonResponse(result)
# 先查询手机号是否已经注册过了
u = UserDAO.queryuserforphone(phone)
if u:
result["data"] = ResultCode.FAIL
result["respcode"] = ResultCode.FAIL
result["errorcode"] = ResultCode.USEREXIST
result["message"] = "注册失败,用户已经存在"
print("注册失败用户存在")
else:
# u1 = UserDAO.queryUserForidentity(identity)
# if u1:
# result["data"] = ResultCode.FAIL
# result["respcode"] = ResultCode.FAIL
# result["errorcode"] = ResultCode.USEREXIST
# result["message"] = "注册失败,该用户已经注册过一次"
# else:
user.usertype = usertype
if (usertype == 0):
user.state = ResultCode.USERQUN_NOT # 客户从手机端注册，，默认为未审核
if (usertype == 1):
user.state = ResultCode.USERQUN_QUNZHU # 代理商从pc端注册，默认为审核
user.image = usericon
user.email = email
user.phone = phone
user.password = password
user.name = name
user.address = address
user.school = school
user.identity = identity
user.wechat = wechat
user.alipay = alipay
user.parameter1 = parameter1
user.parameter2 = parameter2
user.parameter3 = parameter3
user.parameter4 = parameter4
user.parameter5 = parameter5
user.parameter6 = parameter6
user.parameter7 = parameter7
user.parameter8 = parameter8
user.parameter9 = parameter9
user.parameter10 = parameter10
user.parameter11 = parameter11
user.parameter12 = parameter12
user.parameter13 = parameter13
user.parameter14 = parameter14
user.parameter15 = parameter15
user.parameter16 = parameter16
user.parameter17 = parameter17
user.parameter18 = parameter18
user.parameter19 = parameter19
user.parameter20 = parameter20
UserDAO.regist(user) # 注册函数 无返回值
users = UserDAO.login(user) # 同时登陆，返回数据，尤其是ID号
# 如果注册时需要加入群组，这里加入群组
if (qunid):
try:
# 添加用户群关系就是加入了群组
qun = QunDAO.getqunInfoqunid(qunid)
userqun = Userqun()
userqun.userid = users.id
userqun.qunid = qunid
userquntemp = UserqunDAO.getuserqunInfouserqun(userqun)
if (not userquntemp):
if (qun.quntype == ResultCode.QUN_USER
or qun.quntype == ResultCode.QUN_USER_DIARY or
qun.quntype == ResultCode.QUN_USER_DIARY_NOT_USER):
userqun.userstate = ResultCode.USERQUN_NOT
else:
userqun.userstate = ResultCode.USERQUN_YUAN
UserqunDAO.adduserqun(userqun)
# 添加群聊关系
chatuser = Chatuser()
chatuser.send_id = qunid
chatuser.receive_id = users.id
chatuser.usertype = ResultCode.CHATUSER_TYPE_QUN
chatuser.state = ResultCode.CHATUSER_HIDE
chatuser.abid = str(qunid)
chatuser.content = ""
chatuser.time = TimeUtil.getCurrentTime()
chatuser.date = TimeUtil.getCurrentDate()
ChatuserDAO.addchatuser(chatuser)
except Exception as e:
print(e)
usermeback = user2meBack(users)
result["data"] = usermeback
result["respcode"] = ResultCode.SUCCESS
result["errorcode"] = ""
result["message"] = "注册成功"
print("注册成功")
return JsonResponse(result)
def register():
form = RegistrationForm()
if form.validate_on_submit():
# user = User(oxygen_concentration=form.oxygen_concentration.data, dry_cough=form.dry_cough.data,
# septic_shock=form.septic_shock.data, age=form.age.data, breathe_rate=form.breathe_rate.data,
# prior_disease=form.prior_disease.data)
dataset = pd.read_csv(
'C:\ProgramFiles\JetBrains\PyCharmCommunityEdition2019.3.3\Covid19_Final_dataset.csv'
)
# Reading the covid-19 dataset using pandas
# print(dataset.head())
dataset = dataset.replace([np.inf, -np.inf], np.nan).dropna(axis=0)
# Cleaning the dataset to increase the performance
septic_shock = LabelEncoder()
dry_cough = LabelEncoder() # Labelling the string data as integers
prior_disease = LabelEncoder()
dataset['Septic_Shock'] = septic_shock.fit_transform(
dataset['Septic Shock'])
dataset['Dry_Cough'] = dry_cough.fit_transform(
dataset['Dry Cough']) # Creating new columns of labelled data
dataset['Prior_Disease'] = prior_disease.fit_transform(
dataset['Prior Respiratory Disease'])
x = np.array(
dataset.drop([
'Septic Shock', 'Dry Cough', 'Prior Respiratory Disease',
'Severity Status'
],
axis='columns'))
# Creating a feature data
y = np.array(dataset['Severity Status']) # creating the target data
reg = KNeighborsClassifier(
n_neighbors=1
) # training the model using K nearest neighbour algorithm
x_train, x_test, y_train, y_test = train_test_split(x,
y,
test_size=0.1,
random_state=0)
# splitting the data into training and testing data. 30% of the data is for testing
reg.fit(x_train, y_train)
reg.fit(x_train, y_train) # training the model
# print(x_train)
# print('The model gives you information about COVID-19 status based on your visible symptoms')
# print('Enter 0 if your answer is No, if answer is Yes, enter 1')
breadth_rate = form.breathe_rate.data
oxygen_concentration = form.oxygen_concentration.data
age = form.age.data
septic_shock = form.septic_shock.data
dry_cough = form.dry_cough.data
prior_disease = form.prior_disease.data
classified = reg.predict([[
breadth_rate, oxygen_concentration, age, septic_shock, dry_cough,
prior_disease
]])
# classify the input features or symptoms.
if classified == 0 or classified == 1:
temp = 'The symptoms do not promise COVID-19. Stay alert and take every possible precaution.'
if dry_cough == 1:
temp += 'At-home treatments: A cough that results from a virus can’t be treated with antibiotics. ' \
'You can, however, soothe it in the following ways: Keep hydrated by drinking plenty of ' \
'water. Elevate your head with extra pillows when sleeping. Use cough drops to ' \
'soothe your throat. Gargle with warm salt water regularly to remove mucus and soothe ' \
'your throat. Avoid irritants, including smoke and dust. Add honey or ginger to hot ' \
'tea to relieve your cough and clear your airway. Use decongestant sprays to unblock ' \
'your nose and ease breathing.'
if septic_shock == 1:
temp += 'There are a few steps that people can take to reduce their risk of developing sepsis and ' \
'septic shock: Get regular vaccinations against viral infections, such as flu, pneumonia, ' \
'chickenpox, HIV, and other infections that could potentially lead to sepsis. Practice ' \
'good hygiene, such as bathing and changing clothes regularly. Washing the hands frequently, ' \
'especially after handling food, touching pets, and using bathroom facilities, is another way ' \
'to keep infection at bay. Care for and clean any open or gaping wounds. Wear disposable ' \
'gloves, and rinse wounds with clean, soap-free water to clear out debris or dirt. Cover ' \
'the wound to protect it, and see a doctor if the wound does not close or might still ' \
'contain dirt. Look out for signs of infection, such as fever, chills, rapid breathing, ' \
'rash, or confusion. For any bacterial infections, follow the doctor’s advice on how to take ' \
'the antibiotics and finish the whole course of treatment. Store the medicine according to the ' \
'packaging instructions. Treat fungal and parasitic infections as soon as symptoms appear, ' \
'and use medication specific to the particular fungus or parasite. Control diabetes, if ' \
'relevant. Avoid smoking.'
if prior_disease == 1:
temp += 'N95 masks must be worn when taking care of this type of patient. Place the patient in a ' \
'negative airflow room with anteroom. Keep the door closed to maintain the negative airflow.'
string = User(string1=temp)
db.session.add(string)
elif classified == 2:
string = User(string1='The symptoms direct to a moderate case.'
) # telling the user, the condition
db.session.add(string)
else:
string = User(
string1='The symptoms correspond to a critical case.')
db.session.add(string)
db.session.commit()
# db.session.add(user)
# db.session.commit()
return redirect(url_for('details'))
return render_template('Covid-19.html', form=form)
def register(request):
if request.session.get('is_login', None):
return redirect('/homepage/')
if request.method == 'POST':
user_name = request.POST.get('username', '')
pass_word_1 = request.POST.get('password_1', '')
pass_word_2 = request.POST.get('password_2', '')
name = request.POST.get('name', '')
collage = request.POST.get('collage', '')
sex = request.POST.get('sex', '')
classname = request.POST.get('classname', '')
tel = request.POST.get('tel', '')
email = request.POST.get('email', '')
usertype = request.POST.get('usertype', '')
if User.objects.filter(username=user_name):
return render(request, 'login/register.html', {'error': '用户已存在'}, locals())
# 将表单写入数据库
if pass_word_1 != pass_word_2:
return render(request, 'login/register.html', {'error': '两次密码请输入一致'}, locals())
user = User()
user.username = user_name
user.password = pass_word_1
user.tel = tel
user.classname = classname
user.collage = collage
user.email = email
user.name = name
user.sex = sex
user.usertype = usertype
user.save()
# 返回注册成功页面
return redirect('login/login.html')
else:
return render(request, 'login/register.html', locals())
def updateuserinf(request):
result = {}
user = User()
if request.method == "POST":
userid = request.POST.get("userid", None) # 读取post数据，None为默认值
phone = request.POST.get("phone", None) # 读取post数据，None为默认值
qunidstr = request.POST.get("qunid", None) # 读取get数据，None为默认值
password = request.POST.get("password", None) # 读取post数据，None为默认值
name = request.POST.get("name", None) # 读取post数据，None为默认值
identity = request.POST.get("identity", None) # 读取post数据，None为默认值
email = request.POST.get("email", None) # 读取post数据，None为默认值
address = request.POST.get("address", None) # 读取post数据，None为默认值
id_number = request.POST.get("id_number", None) # 读取get数据，None为默认值
push_userId = request.POST.get("push_userId", None) # 读取get数据，None为默认值
push_channelId = request.POST.get("push_channelId", None) # 读取get数据，None为默认值
school = request.POST.get("school", None) # 读取post数据，None为默认值
usertype = request.POST.get("usertype", 0) # 读取post数据，None为默认值
usericon = request.POST.get("usericon", None) # 读取get数据，None为默认值
wechat = request.POST.get("wechat", None) # 读取get数据，None为默认值
alipay = request.POST.get("alipay", None) # 读取get数据，None为默认值
parameter1 = request.POST.get("parameter1", None) # 读取get数据，None为默认值
parameter2 = request.POST.get("parameter2", None) # 读取get数据，None为默认值
parameter3 = request.POST.get("parameter3", None) # 读取get数据，None为默认值
parameter4 = request.POST.get("parameter4", None) # 读取get数据，None为默认值
parameter5 = request.POST.get("parameter5", None) # 读取get数据，None为默认值
parameter6 = request.POST.get("parameter6", None) # 读取get数据，None为默认值
parameter7 = request.POST.get("parameter7", None) # 读取get数据，None为默认值
parameter8 = request.POST.get("parameter8", None) # 读取get数据，None为默认值
parameter9 = request.POST.get("parameter9", None) # 读取get数据，None为默认值
parameter10 = request.POST.get("parameter10", None) # 读取get数据，None为默认值
parameter11 = request.POST.get("parameter11", None) # 读取get数据，None为默认值
parameter12 = request.POST.get("parameter12", None) # 读取get数据，None为默认值
parameter13 = request.POST.get("parameter13", None) # 读取get数据，None为默认值
parameter14 = request.POST.get("parameter14", None) # 读取get数据，None为默认值
parameter15 = request.POST.get("parameter15", None) # 读取get数据，None为默认值
parameter16 = request.POST.get("parameter16", None) # 读取get数据，None为默认值
parameter17 = request.POST.get("parameter17", None) # 读取get数据，None为默认值
parameter18 = request.POST.get("parameter18", None) # 读取get数据，None为默认值
parameter19 = request.POST.get("parameter19", None) # 读取get数据，None为默认值
parameter20 = request.POST.get("parameter20", None) # 读取get数据，None为默认值
if request.method == "GET":
userid = request.GET.get("userid", None) # 读取get数据，None为默认值
phone = request.GET.get("phone", None) # 读取get数据，None为默认值
qunidstr = request.GET.get("qunid", None) # 读取get数据，None为默认值
password = request.GET.get("password", None) # 读取get数据，None为默认值
name = request.GET.get("name", None) # 读取get数据，None为默认值
identity = request.GET.get("identity", None) # 读取get数据，None为默认值
email = request.GET.get("email", None) # 读取get数据，None为默认值
address = request.GET.get("address", None) # 读取get数据，None为默认值
id_number = request.GET.get("id_number", None) # 读取get数据，None为默认值
push_userId = request.GET.get("push_userId", None) # 读取get数据，None为默认值
push_channelId = request.GET.get("push_channelId", None) # 读取get数据，None为默认值
school = request.GET.get("school", None) # 读取get数据，None为默认值
usertype = request.GET.get("usertype", 0) # 读取post数据，None为默认值
usericon = request.GET.get("usericon", None) # 读取get数据，None为默认值
wechat = request.GET.get("wechat", None) # 读取get数据，None为默认值
alipay = request.GET.get("alipay", None) # 读取get数据，None为默认值
parameter1 = request.GET.get("parameter1", None) # 读取get数据，None为默认值
parameter2 = request.GET.get("parameter2", None) # 读取get数据，None为默认值
parameter3 = request.GET.get("parameter3", None) # 读取get数据，None为默认值
parameter4 = request.GET.get("parameter4", None) # 读取get数据，None为默认值
parameter5 = request.GET.get("parameter5", None) # 读取get数据，None为默认值
parameter6 = request.GET.get("parameter6", None) # 读取get数据，None为默认值
parameter7 = request.GET.get("parameter7", None) # 读取get数据，None为默认值
parameter8 = request.GET.get("parameter8", None) # 读取get数据，None为默认值
parameter9 = request.GET.get("parameter9", None) # 读取get数据，None为默认值
parameter10 = request.GET.get("parameter10", None) # 读取get数据，None为默认值
parameter11 = request.GET.get("parameter11", None) # 读取get数据，None为默认值
parameter12 = request.GET.get("parameter12", None) # 读取get数据，None为默认值
parameter13 = request.GET.get("parameter13", None) # 读取get数据，None为默认值
parameter14 = request.GET.get("parameter14", None) # 读取get数据，None为默认值
parameter15 = request.GET.get("parameter15", None) # 读取get数据，None为默认值
parameter16 = request.GET.get("parameter16", None) # 读取get数据，None为默认值
parameter17 = request.GET.get("parameter17", None) # 读取get数据，None为默认值
parameter18 = request.GET.get("parameter18", None) # 读取get数据，None为默认值
parameter19 = request.GET.get("parameter19", None) # 读取get数据，None为默认值
parameter20 = request.GET.get("parameter20", None) # 读取get数据，None为默认值
print("更新资料接口参数：" + "昵称:" + name + "手机号" + phone + "邮箱:" + email + "身份账号" + id_number + "地址:" + address)
user = UserDAO.getUserInfoId(userid)
if(not user):
result["message"]= "修改用户资料失败"
result["respcode"]= ResultCode.FAIL
result["data"]="0"
result["errorcode"]= ResultCode.FAIL
return result
user.id = userid
if(name): user.name=name
if(qunidstr): user.qunid=int(qunidstr)
if(phone): user.phone=phone
if(email): user.email=email
if(id_number): user.id_number=id_number
if(address): user.address=address
if(school): user.school=school
if(wechat): user.wechat=wechat
if(alipay): user.alipay=alipay
if(usericon): user.image=usericon
if(push_userId): user.push_userId=push_userId
if(push_channelId): user.push_channelId=push_channelId
if(parameter1): user.parameter1=parameter1
if(parameter2): user.parameter2=parameter2
if(parameter3): user.parameter3=parameter3
if(parameter4): user.parameter4=parameter4
if(parameter5): user.parameter5=parameter5
if(parameter6): user.parameter6=parameter6
if(parameter7): user.parameter7=parameter7
if(parameter8): user.parameter8=parameter8
if(parameter9): user.parameter9=parameter9
if(parameter10): user.parameter10=parameter10
if(parameter11): user.parameter11=parameter11
if(parameter12): user.parameter12=parameter12
if(parameter13): user.parameter13=parameter13
if(parameter14): user.parameter14=parameter14
if(parameter15): user.parameter15=parameter15
if(parameter16): user.parameter16=parameter16
if(parameter17): user.parameter17=parameter17
if(parameter18): user.parameter18=parameter18
if(parameter19): user.parameter19=parameter19
if(parameter20): user.parameter20=parameter20
#升级为高级会员的条件，能创建群组
if(id_number):
pass
#user.setState(ResultCode.USER_VIP)
try:
#先修该用户资料
UserDAO.updateUserInfo(user)
#根据用户id查询用户信息
users_back = UserDAO.getUserInfoId(user.id)
#将返回信息转变为本文信息类
loginResult = user2meBack(users_back)
result["data"]= loginResult
result["respcode"]= ResultCode.SUCCESS
result["errorcode"]= ""
result["message"]= "修改用户资料成功"
except Exception as e:
print(e)
result["message"]= "修改用户资料失败"
result["respcode"]= ResultCode.FAIL
result["data"]= "0"
result["errorcode"]= ResultCode.FAIL
return result
