def put(self, request):
dict = json.loads(request.body.decode())
old_password = dict.get('old_password')
new_password = dict.get('new_password')
new_password2 = dict.get('new_password2')
if not all([old_password, new_password, new_password2]):
return JsonResponse({'code': 400, 'errmsg': '参数不完整'})
if not request.user.check_password(old_password):
return JsonResponse({'code': 400, 'errmsg': '旧密码输入错误'})
if not re.match(r'^[a-zA-Z0-9]{8,20}$', new_password):
return JsonResponse({'code': 400, 'errmsg': '请设置8-20位的密码'})
if new_password != new_password2:
return JsonResponse({'code': 400, 'errmsg': '两次输入的密码不一致'})
try:
request.user.set_password(new_password)
request.user.save()
except Exception as ret:
return JsonResponse({'code': 400, 'errmsg': '存储数据库失败'})
logout(request)
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
response.delete_cookie('username')
return response
def put(self, request):
data = json.loads(request.body.decode())
old_password = data.get('old_password')
new_password = data.get('new_password')
new_password2 = data.get('new_password2')
if not all([old_password, new_password, new_password2]):
return JsonResponse({'code': 400, 'errmsg': '缺少必要参数'})
user = request.user
# 检查旧密码
if not user.check_password(old_password):
return JsonResponse({'code': 400, 'errmsg': '旧密码输入错误'})
if not re.match(r'^[a-zA-Z0-9]{8,20}$', new_password):
return JsonResponse({'code': 400, 'errmsg': '新密码格式有误'})
if new_password != new_password2:
return JsonResponse({'code': 400, 'errmsg': '新密码2次输入不一致'})
if new_password == old_password:
return JsonResponse({'code': 400, 'errmsg': '新旧密码不能一致'})
# 修改密码
user.set_password(new_password)
user.save()
# 请求用户状态保持
logout(request)
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
response.delete_cookie('username')
return response
def login_handle(request):
'''进行用户登录验证'''
username = request.POST.get("username")
password = request.POST.get("password")
remember = request.POST.get("remember")
vc = request.POST.get("verifycode")
if not all([username, password, vc]):
return JsonResponse({"res": 2})
if vc.upper() != request.session.get("verifycode"):
return JsonResponse({"res": 3})
passport = Passport.objects.get_one_passport(username=username,
password=password)
if passport:
next_url = request.session.get("url_path", reverse("books:index"))
jres = JsonResponse({"res": 1, 'next_url': next_url})
if remember == 'true':
#记住用户名
jres.set_cookie('username', username, max_age=7 * 24 * 3600)
else:
#不需要记住用户名
jres.delete_cookie("username")
request.session["islogin"] = True
request.session["username"] = username
request.session["passport_id"] = passport.id
return jres
#用户名或密码错误
return JsonResponse({"res": 0})
def login_handle(request):
post = request.POST
uname = post['username']
upwd = post['password']
rem_status = post.get('rem_status')
response_code = {}
check_uname = UserInfo.objects.filter(uname=uname).count()
if check_uname == 0:
response_code['user_exist'] = 0
response_code['pwd_check'] = 0
response = JsonResponse({'response_code': response_code})
else:
response_code['user_exist'] = 1
real_password = UserInfo.objects.get(uname=uname).upwd
m = hashlib.sha1()
m.update(upwd)
input_password = m.hexdigest()
if input_password == real_password:
response_code['pwd_check'] = 1
request.session['user_name'] = uname
request.session['user_id'] = UserInfo.objects.get(uname=uname).pk
request.session.set_expiry(1800)
else:
response_code['pwd_check'] = 0
pass
response = JsonResponse({'response_code': response_code})
# 设置cookie
if rem_status == "true":
response.set_cookie('uname', uname)
else:
response.delete_cookie('uname')
return response
def login_check(request):
#获取数据
username = request.POST.get('username')
password = request.POST.get('password')
remember = request.POST.get('remember')
verifycode = request.POST.get('verifycode')
#数据校验
if not all([username, password, remember, verifycode]):
return JsonResponse({'res': 2})
if verifycode.upper() != request.session['verifycode']:
return JsonResponse({'res': 2})
passport = Passport.objects.get_one_passport(username=username,
password=password)
if passport:
#这是数据库里面
next_url = request.session.get('fffff', reverse('books:index'))
jres = JsonResponse({'res': 1, 'next_url': next_url})
if remember == 'true':
jres.set_cookie('username', username, max_age=3600 * 24)
else:
jres.delete_cookie('username')
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
return jres
else:
return JsonResponse({'res': 0})
def login(request):
if request.method == 'GET':
return render(request,'users/login.html')
elif request.method == 'POST':
username = request.POST.get('username')
password = request.POST.get('password')
remember = request.POST.get('remember')
# print(username,password,remember)
if not all([username,password]):
#数据不能为空
return JsonResponse({'res':0})
else:
passport = Passport.objects.get_one_passport(username=username,password=password)
if passport:
#登陆成功 写入session 记录用户登陆状态
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
jres = JsonResponse({'res':2})
# 记住用户名
if remember:
jres.set_cookie('username',username,max_age=7*24*3600)
else:
jres.delete_cookie('uername')
return jres
else:
#账户或密码不正确
return JsonResponse({'res':1})
def check_user(request):
if request.method == "POST":
status = 'ERROR'
username = request.POST['username']
password = request.POST['password']
try:
admin_user = Admin_user.objects.get(username=username)
except ObjectDoesNotExist or MultipleObjectsReturned:
response = {'status': status, 'msg': '帳號錯誤'}
return JsonResponse(response)
user_status = admin_user.status
if user_status == 0:
response = {'status': status, 'msg': '此帳號尚未啟用'}
return JsonResponse(response)
user_password = admin_user.password
check = check_password(password, user_password)
if not check:
response = {'status': status, 'msg': '密碼錯誤'}
return JsonResponse(response)
request.session['admin_username'] = username
request.session['admin_name'] = admin_user.name
request.session['admin_uid'] = admin_user.uid
request.session['admin_premission'] = admin_user.premission
url = request.COOKIES.get('url', '')
response = {'status': 'OK', 'url': url}
res = JsonResponse(response)
res.delete_cookie('url')
return res
def put(self, request):
json_dict = json.loads(request.body.decode())
old_password = json_dict.get('old_password')
new_password = json_dict.get('new_password')
new_password2 = json_dict.get('new_password2')
if not all([old_password, new_password, new_password2]):
return JsonResponse({'code': 400, 'errmsg': '缺少必传参数'})
result = request.user.check_password(old_password)
if not result:
return JsonResponse({'code': 400, 'errmsg': '密码错误'})
if not re.match('^[a-zA-Z0-9-_?+]{8,20}$', new_password):
return JsonResponse({'code': 400, 'errmsg': '密码格式错误'})
if new_password != new_password2:
return JsonResponse({'code': 400, 'errmsg': '两次密码不相同'})
try:
request.user.set_password(new_password)
request.user.save()
except Exception as e:
logger.error(e)
return JsonResponse({'code': 400, 'errmsg': '修改密码失败'})
logout(request)
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
response.delete_cookie('username')
return response
def find_password(request):
"""找回密码3 重置密码"""
# password: 123456
# reset_password: 123456
password = request.POST.get('password')
confirm_pwd = request.POST.get('reset_password')
if password != confirm_pwd:
return JsonResponse({'status': -1, 'msg': '密码不一致'})
phone = request.COOKIES.get('phone')
sessionid = request.COOKIES.get('find_pwd_sessionid')
composer = Composer.objects.filter(phone=phone).first()
if not composer:
return JsonResponse({"status": 0, "msg": "OK"})
# 判断用户是否已经验证过手机号和验证码
if sessionid != multi_encrypt(composer.cid, composer.phone):
return JsonResponse({'status': -1, 'msg': 'session验证失败'})
# 如果验证通过，则重置密码，注意密码需要加密后再存储
composer.password = multi_encrypt(password, phone)
composer.save()
response = JsonResponse({
"status": 0,
"msg": "找回密码成功",
"data": {
"callback": "/login/",
}
})
# 清除在第2步临时颁发的cookies
response.delete_cookie('phone')
response.delete_cookie('find_pwd_sessionid')
return response
def put(self, request):
#提取参数
dict = json.loads(request.body.decode())
old_password = dict.get('old_password')
new_password = dict.get('new_password')
new_password2 = dict.get('new_password2')
#验证参数(整体
if not all([old_password, new_password, new_password2]):
return JsonResponse({'code': 400, 'errmsg': '缺少必传参数'})
#验证参数(单个
#旧密码是否正确用check_password
result = request.user.check_password(old_password) # 验证旧密码
if not result:
return JsonResponse({'code': 400, 'errmsg': '原始密码不正确'})
#新密码是否配对
if not re.match(r'^[0-9A-Za-z]{8,20}$', new_password): # 验证新密码
return JsonResponse({'code': 400, 'errmsg': '密码最少8位,最长20位'})
if new_password != new_password2: # 验证新密码2
return JsonResponse({'code': 400, 'errmsg': '两次输入密码不一致'})
#保存密码用set_password
try: # 修改密码
request.user.set_password(new_password)
request.user.save()
except Exception as e:
logger.error(e)
return JsonResponse({'code': 400, 'errmsg': '修改密码失败'})
#密码重设后退出登录, 删除cookie信息
logout(request) # 清理状态保持信息
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
response.delete_cookie('username')
return response
def delete(self,request):
#删除session信息，logout()中的request.session.flush()
logout(request)
#删除cookie信息，因为前端获取的cookie中的username
response = JsonResponse({'code':0,'errmsg':'OK'})
response.delete_cookie('username')
return response
def login_check(request):
'''进行用户登陆校验'''
username = request.POST.get('username')
password = request.POST.get('password')
remember = request.POST.get('remeber')
if not all([username, password]):
#如果有数据是空
return JsonResponse({'res': 2})
passport = Passport.objects.get_one_passport(username=username,
password=password)
if passport:
next_url = reverse('books:index')
jres = JsonResponse({'res': 1, 'next_url': next_url})
#判断是否记住用户名
if remember == 'true':
jres.set_cookie('username', username, max_age=7 * 24 * 3600)
else:
jres.delete_cookie('username')
#记住用户的登陆状态
request.session['is_login'] = True
request.session['user_name'] = username
request.session['passport_id'] = passport.id
return jres
else:
#用户名密码错误
return JsonResponse({'res': 0})
def login_check(request):
'''登录验证'''
# 1.获取数据
username = request.POST.get('username')
password = request.POST.get('password')
remember = request.POST.get('remember')
# 2.数据校验
if not all([username, password, remember]):
# 数据为空
return JsonResponse({'res': 0})
# 3.进行处理：根据用户名和密码查找账户信息
passport = Passport.objects.get_one_passport(username=username,
password=password)
if passport:
# 返回之前登录的页面
next_url = request.session.get(
'url_path', reverse('goods:index')) # url_path有值返回，没有的话取index
jres = JsonResponse({'res': 1, 'next_url': next_url})
# 判断是否需要记住用户名
if remember == "true":
# 记住用户名
jres.set_cookie('username', username,
max_age=7 * 24 * 3600) # 时间一周
else:
# 不要记住用户名
jres.delete_cookie('username')
# 记住用户的登录状态
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
return jres
else:
# 用户名或密码错误
return JsonResponse({'res': 0})
def put(self, request):
# 1、提取参数
data = json.loads(request.body.decode())
old_password = data.get('old_password')
new_password = data.get('new_password')
new_password2 = data.get('new_password2')
# 2、校验参数
if not all([old_password, new_password, new_password2]):
return JsonResponse({'code': 400, 'errmsg': '参数缺失'})
# 新密码格式校验
if not re.match(r'^[0-9A-Za-z]{8,20}$', new_password):
return JsonResponse({'code': 400, 'errmsg': '密码最少8位,最长20位'})
# 两次输入是否一致校验
if new_password != new_password2:
return JsonResponse({'code': 400, 'errmsg': '两次输入密码不一致'})
# 旧密码校验
# User.set_password()
# User.check_password()
user = request.user
if not user.check_password(old_password):
return JsonResponse({'code': 400, 'errmsg': '旧密码有误！'}, status=400)
# 3、更新数据
user.set_password(new_password)
user.save()
# 补充逻辑：清楚登陆状态
logout(request)
# 4、返回响应
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
response.delete_cookie('username')
return response
def login_check(request):
username = request.POST.get('username')
password = request.POST.get('password')
remember = request.POST.get('remember')
if not all([username, password, remember]):
return JsonResponse({'res': 2})
passport = Passport.object.get_passport(user_name=username,
user_pwd=get_hash(password))
print(username, get_hash(password), passport)
if passport:
print('22222')
next_url = request.session.get('url_path', reverse('book:index'))
print('33333')
jres = JsonResponse({'res': 1, 'next_url': next_url})
if remember == 'true':
print('44444')
jres.set_cookie('username', username, max_age=7 * 24 * 3600)
else:
print('55555')
jres.delete_cookie('username')
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
print('66666')
return jres
else:
return JsonResponse({'res': 0})
def put(self, request):
content = json.loads(request.body.decode())
old_password = content.get('old_password')
new_password = content.get('new_password')
new_password2 = content.get('new_password2')
if not all([old_password, new_password, new_password2]):
return JsonResponse({"code": 400, "errmsg": "缺少必传参数"})
if not re.match(r'^[0-9A-Za-z]{8,20}$', new_password):
return JsonResponse({'code': 400, 'errmsg': '密码最少8位,最长20位'})
if new_password != new_password2:
return JsonResponse({'code': 400, 'errmsg': '两次输入密码不一致'})
if not request.user.check_password(old_password):
return JsonResponse({"code": 400, "errmsg": "密码不正确"})
try:
request.user.set_password(new_password)
request.user.save()
except Exception as e:
logger.error(e)
return JsonResponse({"code": 400, "errmsg": "修改失败"})
logout(request)
response = JsonResponse({"code": 0, "msg": "ok"})
response.delete_cookie('username')
return response
def put(self, request):
# 1.提取参数
data = json.loads(request.body.decode())
old_password = data.get('old_password')
new_password = data.get('new_password')
new_password2 = data.get('new_password2')
# 2.校验参数
if not all([old_password, new_password, new_password2]):
return JsonResponse({'code': 400, 'errmsg': '缺少必要参数'})
if not re.match(r'^[a-zA-Z0-9]{8,20}$', new_password):
return JsonResponse({'code': 400, 'errmsg': 'password格式有误'})
if new_password != new_password2:
return JsonResponse({'code': 400, 'errmsg': '两次输入密码不一致'})
user = request.user
if not user.check_password(old_password):
return JsonResponse({
'code': 400,
'errmsg': '输入的原密码错误'
},
status=400)
# 3.更新数据
user.set_password(new_password)
user.save()
logout(request)
# 4.返回响应
response = JsonResponse({'code': 0, 'errmsg': '修改成功'})
response.delete_cookie('username')
return response
def post(self, request):
'''登录校验'''
if request.method == "POST":
# 初始化一个给AJAX返回的数据
ret = {"status": 0, "msg": ""}
# 从提交过来的数据中 取到用户名和密码
username = request.POST.get("username")
pwd = request.POST.get("password")
user = auth.authenticate(username=username, password=pwd)
remember = request.POST.get('remember')
# print(request.POST.get("remember")) # on
if user:
# 用户名密码正确
# 给用户做登录
if user.is_active:
auth.login(request, user) # 将登录用户赋值给 request.user
ret["msg"] = "/article/index/"
response = JsonResponse(ret)
if remember == 'on':
response.set_cookie("username",
username,
max_age=7 * 24)
else:
response.delete_cookie("username")
return response
else:
ret['status'] = 1
ret['msg'] = "用户未激活"
else:
# 用户名密码错误
ret["status"] = 1
ret["msg"] = "用户名或密码错误！"
return JsonResponse(ret)
def login_check(request):
"""进行用户登录校验"""
#1.获取数据
username = request.POST.get('username')
password = request.POST.get('password')
remember = request.POST.get('remember')
#2.数据校验
if not all([username,password,remember]):
# 有数据为空
return JsonResponse({'res':2})
# 3.进行处理:根据用户名和密码查找账户信息
passport = Passport.objects.get_one_passport(username=username,password=password)
if passport:
# 用户名密码正确
# 获取session中的url_path
next_url = request.session.get('url_path',reverse('books:index'))
jres = JsonResponse({'res': 1, 'next_url': next_url})
# 判断是否需要记住用户名
if remember == 'true':
# 记住用户名
jres.set_cookie('username',username,max_age=7*24*3600)
else:
# 不要记住用户名
jres.delete_cookie('username')
# 记住用户的登陆状态
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
print(jres)
return jres
else:
#用户名或密码错误
return JsonResponse({'res': 0})
def login_check(request):
data = json.loads(request.body.decode('utf-8'))
username = data.get('username')
password = data.get('password')
remember = data.get('remember')
verifycode = data.get('verifycode')
#数据校验
if verifycode.lower() != request.session['verifycode']:
return JsonResponse({'code': 2})
passport = Passport.objects.get_one_passport(username=username,
password=password)
jres = JsonResponse({'code': 200})
if passport:
print("登录成功！")
# 记住用户的登录状态
print(remember, type(remember))
if remember:
#记住用户名
jres.set_cookie('username', username, max_age=7 * 24 * 3600)
else:
#不记住
jres.delete_cookie('username')
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
# return redirect(reverse('books:index'))
return jres
else:
# p = Passport.objects.get_one_passport(username=username)
# if not p:
# return render(request,'users/login.html',{'errormsg':'用户名不存在'})
# return render(request,'users/login.html',{'errormsg':'用户名或密码不正确'})
return JsonResponse({'code': 500})
def login_check(request):
"""登录校验"""
# 获取数据
username = request.POST.get('username')
password = request.POST.get('password')
remember = request.POST.get('remember')
# 验证数据
if not all([username, password]):
return JsonResponse({'res': 2})
# 查询是否存在
passport = Passport.objects.get_one_passport(username=username,
password=password)
print(passport)
if passport:
# 从中间件设置中取出记录的路径，
url_path = request.session.get('url_path',
default=reverse('goods:index'))
# 用户名正确时， 可以考虑记住用户名
rsp = JsonResponse({'res': 1, 'url_path': url_path})
if remember == 'true':
rsp.set_cookie('username', username, max_age=3600 * 24 * 7)
else:
rsp.delete_cookie('username')
# 用户能登录后，要保存登录状态和用户名，便于模板里使用
request.session['is_login'] = True
request.session['username'] = username # session保存在服务器里
request.session['passport_id'] = passport.id
print(passport.id)
return rsp # 表示登录成功
else:
return JsonResponse({'res': 0})
def login_check(request):
username = request.POST.get('username')
password = request.POST.get('password')
remember = request.POST.get('remember')
if not all([username, password, remember]):
return JsonResponse({'res': 2})
passport = Passport.objects.get_one_passport(username=username,
password=password)
if passport:
next_url = reverse('books:index')
jres = JsonResponse({'res': 1, 'next_url': next_url})
if remember == 'true':
jres.set_cookie('username', username, max_age=7 * 24 * 3600)
else:
jres.delete_cookie('username')
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
return jres
else:
return JsonResponse({'res': 0})
def put(self, request):
"""实现修改密码逻辑"""
# 接收参数
dict = json.loads(request.body.decode())
old_password = dict.get('old_password')
new_password = dict.get('new_password')
new_password2 = dict.get('new_password2')
if not all([old_password, new_password, new_password2]):
return JsonResponse({'code': 400, 'errmsg': '缺少必传参数'})
result = request.user.check_password(old_password)
if not result:
return JsonResponse({'code': 400, 'errmsg': '原始密码不正确'})
if not re.match(r'^[0-9A-Za-z]{8,20}$', new_password):
return JsonResponse({'code': 400, 'errmsg': '密码最少8位,最长20位'})
if new_password != new_password2:
return JsonResponse({'code': 400, 'errmsg': '两次输入密码不一致'})
request.user.set_password(new_password)
request.user.save()
logout(request)
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
response.delete_cookie('username')
# # 响应密码修改结果：重定向到登录界面
return response
def login_check(request):
username = request.POST.get('username', '')
password = request.POST.get('password', '')
remember = request.POST.get('remember', '')
verifycode = request.POST.get('verifycode', '')
if not all([username, password, remember, verifycode]):
return JsonResponse({'res': 2})
if verifycode.upper() != request.session['verifycode']:
return JsonResponse({'res': 2})
passport = Passport.object.get_one_passport(username=username,
password=password)
if passport:
# url_path在哪里出来的？？？？？？？？？
# 登录的用户名没有显示？----{if else的语法写错了，没有elif}
next_url = request.session.get('url_path', reverse('books:index'))
jres = JsonResponse({'res': 1, 'next_url': next_url})
if remember == 'true':
jres.set_cookie('username', username, max_age=7 * 24 * 3600)
else:
jres.delete_cookie('username')
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
print(request.session['islogin'], '++++++++')
# 需要返回对象
return jres
else:
return JsonResponse({'res': 0})
def logout_user(request):
logout(request)
response = JsonResponse({'status': 'OK'})
response.delete_cookie('username')
return response
def put(self, request):
# 1.提取参数
user = request.user
data = json.loads(request.body.decode())
new_username = data.get('name')
# 2.校验参数
if not new_username:
return JsonResponse({'errno': 4041, 'errmsg': '缺少必传参数'})
if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', new_username):
return JsonResponse({'errno': 4041, 'errmsg': '用户名格式有误'})
# 3.业务数据处理：修改用户名
try:
user.username = new_username
user.save()
except Exception as e:
return JsonResponse({'errno': 4041, 'errmsg': '用户名修改错误'})
# 清理状态保持信息
logout(request)
response = JsonResponse({'errno': '0', 'errmsg': '修改成功'})
response.delete_cookie('username')
return response
def to_login(request):
name = request.POST.get("name", "").strip()
pswd = request.POST.get("pswd", "").strip()
rmb = request.POST.get("rmb")
# 参数校验
if not all((name, pswd)):
return JsonResponse(dict(errcode=4003, errmsg="参数缺失"))
try:
user = UserInfo.objects.get(ui_name=name)
except Exception as e:
logger.info(e)
return JsonResponse(dict(errcode=4005, errmsg="用户名不存在"))
if not check_password(pswd, user.ui_pswd):
return JsonResponse(dict(errcode=4006, errmsg="密码错误"))
request.session["user_id"] = user.id
request.session["name"] = name
request.session["email"] = user.ui_email
request.session["avatar"] = user.ui_avatar.url
resp_data = dict(errcode=0, errmsg="登录成功")
red_url = request.COOKIES.get("url")
resp_data["url"] = red_url if red_url else "/"
resp = JsonResponse(resp_data, json_dumps_params={"ensure_ascii": False})
resp.delete_cookie("like_arts")
if red_url:
resp.delete_cookie("url")
if rmb:
resp.set_cookie("name", json.dumps(name))
return resp
def login_check(request):
username = request.POST.get('username')
password = request.POST.get('password')
passport = Passport.objects.get_one_passport(username=username,
password=password)
if passport:
# 用户名和密码正确
# return JsonResponse({'res':1})
if request.session.has_key('url_pre_login'):
next = request.session.get('url_pre_login')
else:
# 默认跳转到首页
next = '/'
jres = JsonResponse({'res': 1, 'next': next})
# 是否需要记住用户名
remember = request.POST.get('remember')
if remember == 'true':
# true 为需要记住用户名,将用户名保存在cookie中
jres.set_cookie('username', username)
else:
# 用户名或密码错误
jres.delete_cookie('username')
# 记住用户的登录状态
request.session['islogin'] = True
request.session['passport_id'] = passport.id
request.session['username'] = username
return jres
else:
# 用户名或密码错误
return JsonResponse({'res': 0})
def login_check(request):
print('++++++++login_check')
username = request.POST.get('username')
password = request.POST.get('password')
remember = request.POST.get('remember')
print('++++++++username.password.remember+++++', username, password,
remember)
if not all([username, password]):
return JsonResponse({'res': 2})
passport = Passport.objects.get_one_passport(username=username,
password=password)
print('++++++++passport+++++', passport)
if passport:
next_url = reverse('books:index')
jires = JsonResponse({'res': 1, 'next_url': next_url})
if remember == 'true':
print('++++++++++++cheked+++++++++++', remember)
jires.set_cookie('username', username, max_age=7 * 24 * 3600)
else:
print('+++++++++++remember++++++++++', remember)
jires.delete_cookie('username')
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
print('++++++++request.islogin++++++++', request.session['islogin'])
print('+++++++jires++++++', jires)
return jires
else:
print('00000000000000000')
return JsonResponse({'res': 0})
def login_via_cookie(self, request: HttpRequest):
# Try to get the writer associated with the token
writer = authenticate(request=request)
if writer is None:
response = JsonResponse(
make_error(
'Could not authenticate via cookies, try logging in.'))
response.delete_cookie('a.t')
return response
login(request, writer, backend='siteapi.token_backend.TokenBackend')
# Create a new token and save it to the user's profile
token = make_token(writer.email, writer.username, [])
token = token.decode('utf8')
writer.profile.token = token
writer.save()
# Create the response, attach cookies, and return
response = JsonResponse(
dict(
success=True,
data=dict(email=writer.email, name=writer.username, scopes=[]),
))
response.set_signed_cookie('a.t',
token,
salt=COOKIE_SALT,
expires=one_day_from_now())
return response
def get(self, request):
response = JsonResponse({"status":"success",
"msg":""
})
response.delete_cookie("token")
response.delete_cookie("logined")
return response
def logout(request):
"""Log out user
If user is an Oauth user it will pass back an OAuth redirect to be handled by UI.
"""
is_oauth = hasattr(request.user, 'oauth')
auth_logout(request)
response = redirect('login')
if getattr(settings, "OAUTH_LOGOUT_URL", None):
if is_oauth:
response = JsonResponse({'OAUTH_LOGOUT_URL': settings.OAUTH_LOGOUT_URL})
if settings.SESSION_USER_LAST_ACTIVE_AT in request.session:
del request.session[settings.SESSION_USER_LAST_ACTIVE_AT]
response.delete_cookie(settings.AUTO_LOGOUT_COOKIE_NAME, domain=settings.SESSION_COOKIE_DOMAIN)
return response
def get(self, request):
check = CheckRequest(request)
if not check.admin:
response = JsonResponse({"status": "error",
"code":20000,
"msg": errorCode[20000]})
response.delete_cookie("admin_token")
response.delete_cookie("admin_logined")
return response
data = {"status" : "success",
"msg" : '',
"data" : []
}
resumes = Resume.objects.filter(Q(groupId__exact = check.admin.groupId, display__exact= True), Q(status__exact=0) | Q(status__exact=1)).order_by("status")
for item in resumes:
allRank = Rank.objects.filter(resumeId__exact = item.id)
rank = allRank.filter(qq__exact = check.admin.qq).first()
avgRank = allRank.aggregate(Avg('rank'))
resume = {
"id": item.id,
"jobTitle": item.jobTitle,
"groupId": item.groupId,
"qq": item.qq,
"email": item.userEmail,
"username": item.username,
"sex": item.sex,
"age": item.age,
"yearsOfWorking": item.yearsOfWorking,
'school': item.school,
'education': item.education,
"lastDate": item.lastDate,
"content": item.content,
"status": item.status
}
if not rank:
resume['myRank'] = -1
else:
resume['myRank'] = rank.rank
if not avgRank['rank__avg']:
resume['averageRank'] = -1
else:
resume['averageRank'] = avgRank['rank__avg']
data['data'].append(resume)
return JsonResponse(data)
