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 zhuce(request): # 注册验证
ready = int(request.get_signed_cookie("denglu", 0, "xinguan"))
if request.method == "GET":
response = redirect(
reverse("jianyue:lifadian_geren", kwargs={"dianzhulianxi": ready}))
return response
elif request.method == "POST":
data_getter = request.POST
dianzhuming = data_getter.get("dianzhuming")
shenfenzheng = data_getter.get("shenfenzheng")
dianzhulianxi = data_getter.get("dianzhulianxi")
dianming = data_getter.get("dianming")
dizhi = data_getter.get("dizhi")
mima = data_getter.get("mima")
try:
this = lifadian.objects.create(dianzhuming=dianzhuming,
shenfenzheng=shenfenzheng,
dianzhulianxi=dianzhulianxi,
dianming=dianming,
dizhi=dizhi,
mima=mima)
dizhi.objects.create(lifadian=this, **ger_address_info(dizhi))
request.session['dianzhulianxi'] = dianzhulianxi
response = JsonResponse({"status": 1, "msg": "注册成功"})
response.set_signed_cookie("denglu", dianzhulianxi, "xinguan")
return response
except IntegrityError:
return JsonResponse({"status": 0, "msg": "手机号码或身份证已注册"})
except:
return JsonResponse({'status': -1, 'msg': '注册失败'})
def login_check(request):
"""登录校验"""
# request.POST 保存 POST模式表单信息
username = request.POST['username']
pwd = request.POST['password']
if username == "":
return JsonResponse({'res': 0, 'message': '请输入用户名'})
if pwd == "":
return JsonResponse({'res': 0, 'message': '请输入密码'})
try:
us = UserInfo.objects.get(username=username)
if hashlib.sha1(
(pwd + us.username).encode('utf-8')).hexdigest() == us.password:
res = 1
response = JsonResponse({'res': res}) # 设置COOKIES
response.set_cookie('username', username, max_age=7 * 24 * 3600)
response.set_signed_cookie('username', username, salt='wangda')
# 设置session
request.session['username'] = username
request.session.set_expiry(24 * 3600)
return response
else:
res = 0
return JsonResponse({'res': res, 'message': '密码错误'})
except:
return JsonResponse({'res': 0, 'message': '此用户名不存在'})
def login(request):
response = {}
if request.method == 'POST':
email = json.loads(request.body)['email']
password = json.loads(request.body)['password']
password = decrypt_pass(password).decode()
try:
user = User.objects.get(user_email=email)
except:
response['code'] = 300
print('fail')
response['data'] = {'msg': "User does not exist"}
return JsonResponse(response)
if user.active == False:
response['code'] = 300
response['data'] = {'msg': "is not active"}
return JsonResponse(response)
elif user.user_password == password:
response['code'] = 200
response['data'] = {'msg': "success"}
#这里设置了cookie，最长使用时间为1小时
userid = user.id
jsonresponse = JsonResponse(response)
jsonresponse.set_signed_cookie(key='userid',
value=userid,
salt='yyh',
max_age=3600)
return jsonresponse
else:
response['code'] = 300
response['data'] = {'msg': "Password is wrong"}
return JsonResponse(response)
def logout(request):
response = {}
if request.method == 'POST':
#email_test = json.loads(request.body)['email']
#先检查cookie
userid = check_cookie(request)
if userid == -1:
response['code'] = 300
response['data'] = {'msg': "cookie out of date"}
return JsonResponse(response)
else:
try:
User.objects.get(id=userid)
response['code'] = 200
response['data'] = {'msg': "success"}
jsonresponse = JsonResponse(response)
jsonresponse.set_signed_cookie(key='userid',
value=userid,
salt='yyh',
max_age=1)
print(userid)
return jsonresponse
except:
response['code'] = 300
#if email == email_test:
#response['data'] = {'msg': "unkown wrong"}
#else:
response['data'] = {'msg': "User does not exist"}
return JsonResponse(response)
def get_lastweek_articles(request):
"""
游客用户返回过去一周的文章 id 列表；登录用户返回过去一周的未读数
"""
uid = request.POST.get('uid', '')
user = get_login_user(request)
sub_feeds = json.loads(request.POST.get('sub_feeds') or '[]')
unsub_feeds = json.loads(request.POST.get('unsub_feeds') or '[]')
ext = request.POST.get('ext', '')
reach_sub_limit = False
logger.info(f"查询未读数：`{uid}`{ext}")
if user is None:
my_sub_feeds = get_visitor_subscribe_feeds(tuple(sub_feeds),
tuple(unsub_feeds))
reach_sub_limit = len(my_sub_feeds) == settings.VISITOR_SUBS_LIMIT
else:
my_sub_feeds = get_user_subscribe_feeds(user.oauth_id,
user_level=user.level)
if user.level < 10:
reach_sub_limit = len(my_sub_feeds) == settings.USER_SUBS_LIMIT
# 异步更新任务
django_rq.enqueue(update_sites_async, list(my_sub_feeds))
# 获取文章索引列表
my_toread_articles = set()
for site_id in my_sub_feeds:
my_toread_articles.update(get_recent_site_articles(site_id))
my_toread_articles = list(my_toread_articles)
if user:
my_unread_count = get_user_unread_count(user.oauth_id,
my_toread_articles)
# 标记用户登陆
set_user_visit_day(user.oauth_id)
response = JsonResponse({"result": my_unread_count})
if reach_sub_limit:
response.set_signed_cookie('toast',
'SUBS_LIMIT_ERROR_MSG',
max_age=20)
return response
else:
response = JsonResponse({"result": my_toread_articles})
if reach_sub_limit:
response.set_signed_cookie('toast',
'SUBS_LIMIT_ERROR_MSG',
max_age=20)
return response
def info(_req: HttpRequest, project: str, uuid: str = ""):
_project = IosProjectInfo.objects.filter(
project=project).first() # type: IosProjectInfo
udid = ""
if not _project:
return {}
ret = str_json(_project.comments)
ready = False
if uuid:
_user = UserInfo.objects.filter(uuid=uuid).first() # type: UserInfo
if _user:
ready = True
udid = _user.udid
else:
Log("上传的uuid无效[%s]" % uuid)
else:
uuid = _req.get_signed_cookie("uuid", "", salt="zhihu")
_user = UserInfo.objects.filter(uuid=uuid).first() # type: UserInfo
if _user:
ready = True
udid = _user.udid
else:
Log("cookie中的uuid无效[%s]" % uuid)
if ready:
ret.update({
"ready": True,
})
_task = TaskInfo.objects.filter(uuid=uuid).first() # type:TaskInfo
if _task:
if _task.state == "fail" or _task.expire.timestamp() * 1000 < now(
):
__add_task(_user)
else:
uuid = _newbee(_project)
ret.update({
"ready": False,
})
ret.update({
"uuid": uuid,
})
rsp = JsonResponse({
"ret": 0,
"result": ret,
"download_id": random_str(32),
})
rsp.set_signed_cookie("uuid", uuid, salt="zhihu", expires=3600 * 24)
if udid:
rsp.set_signed_cookie("udid",
_user.udid,
salt="zhihu",
expires=300 * 3600 * 24)
return rsp
def login_check(request):
"""检查登录"""
if request.method == "POST":
userid = request.POST.get("input_userid")
password = request.POST.get("input_pwd")
u = User.objects.filter(Q(id__exact=userid) & Q(user_password__exact=password)) # 判断id与密码是否存在
if not u:
return JsonResponse({'res': '0'}) # 登录失败返回0
else:
data = {'res': '1'}
# response = HttpResponse(json.dumps(data), content_type="application/json")
response = JsonResponse(data)
response.set_signed_cookie('user_id', userid, salt='test') # 设置加密cookie
return response
def login_via_data(self, request: HttpRequest):
# Ensure the request is sending JSON
if not request.content_type == 'application/json':
return JsonResponse(make_error('Expected application/json'))
# Try to parse the request payload
try:
data = json.loads(request.read().decode('utf8'))
except json.JSONDecodeError:
return JsonResponse(make_error('Expected application/json'))
# Validate the request payload
validation_errors = self.validate_post(data)
if validation_errors:
return JsonResponse(
make_error('Data failed validation', validation_errors))
# Get the writer associated with this email address
try:
writer = User.objects.get(email=data['email'])
except User.DoesNotExist:
return JsonResponse(
make_error(
'Could not find account for "{email}"'.format(**data)))
# Verify that the password is correct
writer = authenticate(username=writer.username,
password=data['password'])
if writer is None:
return JsonResponse(make_error('Wrong password.'))
login(request, writer)
# Create the JSON web token
token = make_token(writer.email, writer.username, [])
writer.profile.token = token
writer.save()
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
