def post(self,request):
sku_id = request.POST.get('sku_id')
if not sku_id:
return JsonResponse({'code':1,'message':'参数缺少'})
# 2.从购物车中删除数据
if not request.user.is_authenticated():
# 用户未登录,从cookie中删除
cart_json = request.COOKIES.get('cart')
if cart_json is not None:
cart = json.loads(cart_json)
if sku_id in cart:
del cart[sku_id]
response = JsonResponse({'code':0,'message':'删除成功'})
response.set_cookie('cart',json.dumps(cart))
return response
else:
# 用户已登录,从redis中删除
redis_conn = get_redis_connection('default')
user_id = request.user.id
redis_conn.hdel('cart_%s'%user_id,sku_id)
return JsonResponse({'code':0,'message':'删除成功'})
def post(self, request):
#获取参数，sku_id
sku_id = request.POST.get('sku_id')
#检验参数，not即可
if not sku_id:
return JsonResponse({'code': 1, 'message': '参数不对'})
#判断用户是否登录,#已登录就删除redis中商品记录
if request.user.is_authenticated():
#创建连接redis的对象
redis_conn = get_redis_connection('default')
#获取user_id
user_id = request.user.id
redis_conn.hdel('cart_%s' % user_id, sku_id)
#未登录就删除cookie中商品记录,重新写入删除后的cookie
else:
cart_json = request.COOKIES.get('cart')
if cart_json:
cart_dict = json.loads(cart_json)
else:
cart_dict = {}
#字典删除键对应的value
del cart_dict[sku_id]
#重新在响应中写入cookie
response = JsonResponse({'code': 0, 'message': '删除购物车成功'})
response.set_cookie('cart', json.dumps(cart_dict))
return response
return JsonResponse({'code': 0, 'message': '删除成功'})
def do_login(request):
# prefix_code: +86
# type: phone
# value: 13136130957
# password: sfsdfsa
phone = request.POST.get('value')
password = request.POST.get('password')
composer = Composer.objects.filter(phone=phone).first()
if not composer:
return JsonResponse({"status": -1, "msg": "用户名或密码错误"})
# 验证密码的时候和注册一样，先将密码加密后再与数据库中的密码字符串比对
if composer.password != multi_encrypt(password, phone):
return JsonResponse({"status": -1, "msg": "用户名或密码错误"})
response = JsonResponse({
"status": 0,
"msg": "登录成功",
"data": {
"callback": "/show_list/",
}
})
# 将登录成功的凭证（也就是Authorization）写入cookie
response.set_cookie('cid', composer.cid)
response.set_cookie('Authorization',
multi_encrypt(composer.cid, composer.phone))
return response
def login(request, redirect_after_registration=False, registration_data=None):
if redirect_after_registration:
token = create_login_token(registration_data)
else:
# check credentials
post_data = json.loads(request.body)
username = post_data['username']
password = post_data['password']
u = authenticate(username=username, password=password)
# if authenticated, create and return token
if u is not None:
token = create_login_token({
'username': u.username,
'email': u.email
})
else:
return JsonResponse({'status': 'fail'}, status=401)
print('token is', token['token'])
res = JsonResponse({
'status': 'success',
'data': str(token['token'], 'utf-8')
})
res.set_cookie('token', value=token['token'], expires=token['exp'])
return res
def post(self, request):
# 接收参数：sku_id
sku_id = request.POST.get('sku_id')
# 校验参数：not，判断是否为空
if not sku_id:
return JsonResponse({'code': 1, 'message': 'sku_id为空'})
# 判断用户是否登录
try:
GoodsSKU.objects.get(id=sku_id)
except GoodsSKU.DoesNotExist:
return JsonResponse({'code': 2, 'message': '删除的商品不存在'})
# 如果用户登陆，删除redis中购物车数据
if request.user.is_authenticated():
redis_conn = get_redis_connection('default')
user_id = request.user.id
redis_conn.hdel('cart_%s' % user_id, sku_id)
else:
# 如果用户未登陆，删除cookie中购物车数据
cart_json = request.COOKIES.get('cart')
if cart_json is not None:
cart_dict = json.loads(cart_json)
# 删除字典中某个key及对应的内容
del cart_dict[sku_id]
# 将json转化成字符串
new_cart_json = json.dumps(cart_dict)
#将数据写入到cookie
response = JsonResponse({'code': 0, 'message': '删除成功'})
response.set_cookie('cart', new_cart_json)
return response
return JsonResponse({'code': 0, 'message': '删除成功'})
def put(self, request):
data = json.loads(request.body.decode())
selected = data.get('selected')
user = request.user
#判断用户是否登录
if user.is_authenticated:
#已登录
conn = get_redis_connection('carts')
cart_dict = conn.hgetall('carts_%' % user.id)
sku_ids = cart_dict.keys()
# 2、设置全/全取消
if selected:
conn.sadd('selected_%s' % user.id, *sku_ids)
else:
conn.srem('selected_%s' % user.id, *sku_ids)
return JsonResponse({'code': 0, 'errmsg': 'ok'})
else:
# 未登录
cookie_str = request.COOKIES.get('carts')
cart_dict = carts_cookie_decode(cookie_str)
#判断选中状态
sku_ids = cart_dict.keys()
for sku_id in sku_ids:
cart_dict[sku_id]['selected'] = selected
#覆盖写入cookie购物车
cookie_str = carts_cookie_encode(cart_dict)
response = JsonResponse({'code': 0, 'errmsg': "ok"})
response.set_cookie("carts", cookie_str)
return response
def login(request):
if request.method == "POST":
phone = request.POST.get("phone")
password = request.POST.get("password")
if phone is None or password is None:
return JsonResponse({
"reason": "Need phone or password",
},
status=400)
try:
result = models.User.objects.get(phone=phone, password=password)
except models.User.DoesNotExist:
return JsonResponse({
"reason": "Username or password wrong!",
},
status=400)
uuid = sessions.create_session(_id=result.id)
resp = JsonResponse({
"authorization": uuid,
"user_id": result.id
},
status=200)
resp.set_cookie("sessionID", uuid)
return resp
else:
return JsonResponse({}, status=405)
def post(self,request):
data = json.loads(request.body.decode())
username = data.get('username')
password = data.get('password')
remembered = data.get('remembered')
#验证登录数据
if not all([username,password]):
return JsonResponse({'code':400,'errmsg':'参数不全'})
#用户名为手机号时也可以登录。User.USERNAME_FIELD默认是数据库username查询。
if re.match('1[3-9]\d{9}',username):
User.USERNAME_FIELD='mobile'
else:
User.USERNAME_FIELD='username'
#authenticate传递用户名和密码，如果有用户名和密码正确，返回User。否则返回None。
user = authenticate(username=username,password=password)
if user is None:
return JsonResponse({'code':400,'errmsg':'参数错误'})
#如果用户名密码正确，状态保持(session)
login(request,user)
if remembered:
request.session.set_expiry(None)
else:
request.session.set_expiry(0)
response = JsonResponse({'code':0,'errmsg':'OK'})
response.set_cookie('username',username)
return response
def delete(self, request):
data = json.loads(request.body.decode())
sku_id = data.get('sku_id')
user = request.user
#已登录
if user.is_authenticated:
conn = get_redis_connection('carts')
# 1.1 删除购物车哈希数据——carts_user_id : {sku_id : count}
conn.hdel('carts_%s' % user.id, sku_id)
#删除集合中的sku_id
conn.srem('selected_%s' % user.id, sku_id)
return JsonResponse({'code': 0, 'errmsg': 'ok'})
else:
#获取cookie购物车数据
cookie_str = request.COOKIES.get('carts')
cart_dict = carts_cookie_decode(cookie_str)
#删除cookie购物车字典中的sku_id键值对
if sku_id in cart_dict:
cart_dict.pop(sku_id)
#新的数据写入cookie中
cart_str = carts_cookie_encode(cart_dict)
response = JsonResponse({
'code': 0,
'errmsg': 'ok',
})
response.set_cookie('carts', cart_dict)
return response
def login(request):
result = {"state": "error", "data": ""}
if request.method == "POST":
userdata = request.POST
username = userdata.get("phone")
password = userdata.get("password")
vdata = userdata.get("remember")
cookiedata = request.COOKIES.get("key")
if vdata == cookiedata:
try:
u = User.objects.get(phone=username)
except:
result["data"] = "请输入正确的用户名"
return JsonResponse(result)
else:
postPassword = getmd5(password)
if postPassword == u.password:
result["state"] = "success"
response = JsonResponse(result)
response.set_cookie("phone", u.phone)
request.session["phone"] = u.phone
request.session["user_id"] = u.id
return response
else:
result["data"] = "密码错误"
return JsonResponse(result)
else:
result["data"] = "请刷新重试"
return JsonResponse(result)
def delete(self, request):
"""
接收和检验参数
:param request:
:return:
"""
data = json.loads(request.body.decode())
sku_id = data.get('sku_id')
# count =data.get('count')
# selected = data.get('selected')
user = request.user
if user.is_authenticated:
conn = get_redis_connection('carts')
conn.hdel('carts_%s' % user.id, sku_id)
return JsonResponse({'code': 0, 'errmsg': '删除购物车成功'})
else:
cookie_cart = request.COOKIES.get('carts')
if cookie_cart:
cart_dict = carts_cookie_decode(cookie_cart)
else:
cart_dict = {}
response = JsonResponse({'code': 0, 'errmsg': '删除购物车成功'})
if sku_id in cart_dict:
del cart_dict[sku_id]
# cart_dict.pop[sku_id]
cart_data = carts_cookie_encode(cart_dict)
response.set_cookie('carts', cart_data)
return response
def post(self, request):
""""""
# 获取参数
sku_id = request.POST.get("sku_id")
# 参数校验
if not sku_id:
return JsonResponse({"code": 1, "message": "参数缺失"})
# 业务处理， 删除购物车数据
if not request.user.is_authenticated():
# 用户未登录，操作cookie
cart_json = request.COOKIES.get("cart")
if cart_json is not None:
cart = json.loads(cart_json)
# 判断cart字典中是否存在sku_id键
if sku_id in cart:
# 删除cookie中cart字典的商品记录
del cart[sku_id]
response = JsonResponse({"code": 0, "message": "删除成功"})
response.set_cookie("cart", json.dumps(cart))
return response
else:
return JsonResponse({"code": 0, "message": "删除成功"})
else:
# 用户已登录，操作redis
redis_conn = get_redis_connection("default")
user_id = request.user.id
# 删除redis中的sku_id字段的记录
redis_conn.hdel("cart_%s" % user_id, sku_id)
return JsonResponse({"code": 0, "message": "删除成功"})
def delete(self,request):
"""删除购物车"""
data=json.loads(request.body.decode())
sku_id=data.get('sku_id')
selected=data.get('selected')
user=request.user
if user.is_authenticated:
#已登录用户
redis_conn=get_redis_connection('carts')
redis_conn.hdel('carts_%s'%user.id,sku_id)
redis_conn.srem('selected_%s'%user.id,sku_id)
return JsonResponse({
'code':0,
"errmsg":'删除购物车成功'
})
else:
#未登录用户呢
cookie_cart=request.COOKIES.get('carts')
cart_dict={}
if cookie_cart:
cart_dict=pickle.loads(base64.b64decode(cookie_cart.encode()))
response=JsonResponse({
'code':0,
'errmsg':'删除成功'
})
if sku_id in cart_dict:
del cart_dict[sku_id]
cart_data=base64.b64encode(pickle.dumps(cart_dict)).decode()
response.set_cookie('carts',cart_data)
return response
def check_token(request):
identity = json.loads(request.body)
pemilih = Pemilih.objects.filter(nim=identity['nim'])
if len(pemilih) > 0:
pemilih = pemilih[0]
if pemilih.token == '':
retcode = 1
retmes = 'Invalid token in db, please contact admin'
elif pemilih.token == identity['token']:
if pemilih.hasvoted == True:
retcode = 1
retmes = 'You have already voted!'
else:
retcode = 4
retmes = 'Success!'
else:
retcode = 1
retmes = 'Token invalid!'
else:
retcode = 1
retmes = 'not registered as voter.'
response = JsonResponse({'code': retcode, 'return': retmes})
if retcode == 4:
response.set_cookie('token', identity['token'])
response.set_cookie('nim', identity['nim'])
return response
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 post(self, request):
content = json.loads(request.body.decode())
username = content.get('username')
password = content.get('password')
remembered = content.get('remembered')
if not all([username, password]):
return JsonResponse({"code": 400, "errmsg": "缺少必选参数"})
user = authenticate(username=username, password=password)
if user is None:
return JsonResponse({"code": 400, "errmsg": '用户名或者密码错误'})
login(request, user)
if remembered != True:
request.session.set_expiry(0)
response = JsonResponse({"code": 0})
response.set_cookie('username', user.username)
return response
else:
request.session.set_expiry(None)
response = JsonResponse({"code": 0})
response.set_cookie('username',
user.username,
max_age=3600 * 24 * 14)
return response
def login(request: HttpRequest):
print('++++++++++++++++++++++')
print(request.POST)
print(request.body)
print('++++++++++++++++++++++')
try:
payload = simplejson.loads(request.body) # 获取登录信息数据
email = payload['email']
password = payload['password']
user = User.objects.filter(email=email).first()
if user:
if bcrypt.checkpw(password.encode(), user.password.encode()):
# 验证通过，返回true
token = gen_token(user.id)
res = JsonResponse({
'user': {
'user_id': user.id,
'name': user.name,
'email': user.email
},
'token': token
})
res.set_cookie('jwt', token)
return res
else:
return HttpResponseBadRequest('登录失败1')
else:
return HttpResponseBadRequest('登录失败2')
except Exception as e: # 有任何异常都返回
print(e)
# 这里返回实例，不是异常类
return HttpResponseBadRequest('登录失败3')
def post(self, request):
'''
登录验证ldap账号密码以及验证码,成功则写cookie
'''
try:
data = json.loads(request.body)
ldap_username = data["ldap_username"]
password = data["password"]
captcha = data["captcha"]
# 比较验证码
if request.session["captcha"].lower() != captcha.lower():
return JsonResponse({"status": False, "msg": "验证码错误!"})
# 验证ldap账号密码
aes = Aes()
opt = options.objects.all()[0]
ldap_client = MyLdap(opt.ldap_url,
opt.base_dn,
opt.ldap_admin,
aes.decrypt(opt.ldap_pass))
if not ldap_client.ldap_get(uid=ldap_username, passwd=password):
return JsonResponse({"status": False, "msg": "账号或密码输入错误!"})
# 写cookie,设置cookie_domain
rsa = Rsa()
now = time.time()
public_key = rsakeys.objects.all()[0].public_key
user_info = "{0}|||||{1}".format(ldap_username, now)
response = JsonResponse({"status": True})
response.set_cookie('sso_user', rsa.crypto(
public_key, user_info), domain=options.objects.all()[0].cookie_domain)
# request.session.set_expiry(30*60)
return response
except Exception as e:
log().error(traceback.format_exc())
return JsonResponse({"status": False, "msg": str(e)})
def login_check(request):
'''登陆验证'''
passport = request.POST.get('username')
password = request.POST.get('password')
# print(passport)
# print(password)
if not all([passport, password]):
return JsonResponse({'res': 0, 'errmsg': '登陆参数不能为空'})
try:
# 1.按照电话号码进行登陆
username = Passport.objects.get(tel=passport,
password=get_hash(password))
# 2.按照邮箱登陆
# 3.按照用户名登陆
# 如果查询到信息
if username:
# 1.记录登陆状态
print(request.session.get('url_path'))
next_url = request.session.get('url_path', reverse('goods:index'))
r_ajax = JsonResponse({"res": 1, 'next_url': next_url})
r_ajax.set_cookie('username', username, max_age=2 * 7 * 24 * 3600)
# 保存登录状态
request.session['islogin'] = True
request.session['username'] = username.username
request.session['username_id'] = username.id
print(request.session.get('username'))
print(request.session.get('username_id'))
print(request.session.get('islogin'))
return r_ajax
except:
return JsonResponse({'res': 0, 'errmsg': '用户名或密码错误'})
def put(self, request):
data = json.loads(request.body.decode())
sku_id = data.get('sku_id')
count = data.get('count')
selected = data.get('selected')
try:
sku = SKU.objects.get(id=sku_id)
except SKU.DoesNotExist:
return JsonResponse({'code': RETCODE.NODATAERR, 'errmsg': '没有此信息'})
user = request.user
if user.is_authenticated:
redis_conn = get_redis_connection('carts')
redis_conn.hset('carts_%s' % user.id, sku_id, count)
if selected:
redis_conn.sadd('selected_%s' % user.id, sku_id)
else:
redis_conn.srem('selected_%s' % user.id, sku_id)
data = {
'count': count,
'id': sku_id,
'selected': selected,
'name': sku.name,
'default_image_url': sku.default_image.url,
'price': sku.price,
'amount': sku.price * count,
}
return JsonResponse({
'code': RETCODE.OK,
'errmsg': 'ok',
'cart_sku': data
})
else:
cookie_str = request.COOKIES.get('carts')
if cookie_str is not None:
cookie_dict = pickle.loads(base64.b64decode(cookie_str))
else:
cookie_dict = {}
if sku_id in cookie_dict:
cookie_dict[sku_id] = {'count': count, 'selected': selected}
cookie_data = base64.b64encode(pickle.dumps(cookie_dict))
data = {
'count': count,
'id': sku_id,
'selected': selected,
'name': sku.name,
'default_image_url': sku.default_image.url,
'price': sku.price,
'amount': sku.price * count,
}
response = JsonResponse({
'code': RETCODE.OK,
'errmsg': 'ok',
'cart_sku': data
})
response.set_cookie('carts', cookie_data, max_age=7 * 24 * 3600)
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 signin(request):
name = request.POST.get('name')
password = request.POST.get('password')
token = sha1(LOGIN_TOKEN + name).hexdigest()
if '@' in name:
try:
user = InsUser.objects.get(email=name)
except:
user = False
else:
try:
user = InsUser.objects.get(username=name)
except:
user = False
if not user:
return JsonResponse({'false': '用户名或邮箱错误'})
truepwd = user.password
if password != truepwd:
return JsonResponse({'false': '密码错误'})
response = JsonResponse({'true': '登录成功'})
request.session['islogin'] = user.username
response.set_cookie('islogin', user.username)
response.set_cookie('token', token)
log_info = 'username:{}'.format(name)
#signin_logger.info(log_info)
return response
def landing(request):
user = request.POST
name = user.get("username")
password = user.get("userpassword")
context = {
"title": "登陆"
}
if not all([name, password]):
return render(request, 'h2_home/landing.html', context)
re_au = re.match(r'\d{12}',name)
try:
if re_au:
ret = UserInfo.objects.get(id=name)
else:
ret = UserInfo.objects.get(email=name)
except:
context["error"] = 1
return JsonResponse(context)
if not (ret.passwrod == password):
context["error"] = 1
return JsonResponse(context)
uid = uuid.uuid5(uuid.NAMESPACE_DNS, name)
context["error"] = 0
try:
next_s = request.session['next']
except:
next_s = "/"
context["next"] = next_s
context["uid"]= uid
context["user"]=ret.id
response = JsonResponse(context)
redis_db.set(ret.id, uid,ex=1*24*60*60)
response.set_cookie("uid", uid)
response.set_cookie('user', ret.id)
return response
def post(self, request):
# 获取参数：sku_id
sku_id = request.POST.get('sku_id')
# 校验参数
if not sku_id:
return JsonResponse({'code': 1, 'message': '参数缺少'})
# 判断用户是否登陆
if request.user.is_authenticated():
# 如果是登陆，就从redis是数据库中删除
redis_conn = get_redis_connection('default')
user_id = request.user.id
redis_conn.hdel('cart_%s'%user_id, sku_id)
else:
# 如果是未登陆，就从cookie是数据库中删除
cart_json = request.COOKIES.get('cart')
if cart_json is not None:
cart_dict = json.loads(cart_json)
# 判断要删除的key-value是否存在
if sku_id in cart_dict:
del cart_dict[sku_id]
# 把删除的结果重新写入到用户的浏览器
response = JsonResponse({'code': 0, 'message': '删除成功'})
response.set_cookie('cart', json.dumps(cart_dict))
return response
return JsonResponse({'code': 0, 'message': '删除成功'})
def put(self, request):
data = json.loads(request.body.decode())
selected = data.get('selected')
user = request.user
if user is not None and user.is_authenticated:
redis_conn = get_redis_connection('carts')
cart = redis_conn.hgetall('carts_%s' % user.id)
sku_id_list = cart.keys()
if selected:
# 全选
redis_conn.sadd('selected_%s' % user.id, *sku_id_list)
else:
# 取消全选
redis_conn.srem('selected_%s' % user.id, *sku_id_list)
return JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
else:
carts = request.COOKIES.get('carts')
if carts is not None:
carts = pickle.loads(base64.b64decode(carts))
for sku_id in carts:
carts[sku_id]['selected'] = selected
cookie_cart = base64.b64encode(pickle.dumps(carts))
response = JsonResponse({'code': RETCODE.OK, 'errmsg': '全选购物车成功'})
response.set_cookie('carts', cookie_cart, max_age=3600 * 24)
return response
def login(request):
if request.method == 'GET':
return render(request, 'happy/login.html')
name = request.POST.get('myname')
password = request.POST.get('mypwd')
user = UserInfo.objects.filter(uname=name)
if user.exists():
user = user.first()
if user.upwd == pass_sec(password):
user.user_token = creat_token()
user.save()
resp = JsonResponse({
'result': '200',
'token': user.user_token,
'user_id': user.id,
'user_name': user.uname,
'msg': '登录成功！'
})
resp.set_cookie('user_token', user.user_token)
resp.set_cookie('user_id', user.id)
return resp
return JsonResponse({'result': '100', 'msg': '用户名或密码错误！'})
return JsonResponse({'result': '100', 'msg': '用户名或密码错误！'})
def login_check(request):
username = request.POST.get('username')
password = request.POST.get('password')
remeber = request.POST.get('remeber')
if not all([username, password, remeber]):
return JsonResponse({'res': 2})
password = Passport.object.get_one_passport(username=username,
password=password)
if passport:
next_url = reverse('books:index')
jres = JsonResponse({'res': 1, 'next_url': next_url})
#判断是否需要记住用户名
if remeber == 'true':
jres.set_cookie('username', username, max_length=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):
cart_dict = json.loads(request.body)
selected = cart_dict.get('selected', True)
if not isinstance(selected, bool):
return JsonResponse({'code': 400, 'errmsg': '参数错误'})
if request.user.is_authenticated:
redis_conn = get_redis_connection('carts')
redis_cart, redis_selected = get_redis_carts(request)
sku_ids = redis_cart.keys()
if selected:
redis_conn.sadd('selected_%s' % request.user.id, *sku_ids)
else:
redis_conn.srem('selected_%s' % request.user.id, *sku_ids)
return JsonResponse({'code': 0, 'errmsg': 'ok'})
else:
cookie_cart = get_carts_from_cookie(request)
sku_ids = cookie_cart.keys()
for sku_id in sku_ids:
cookie_cart[sku_id]['selected'] = selected
data = get_cookie_cart_data(cookie_cart)
response = JsonResponse({'code': 0, 'errmsg': 'ok'})
response.set_cookie('carts', data)
return response
def auth_user(request):
if 'user_login' not in request.POST or 'user_pass' not in request.POST:
print "ERR: no fields user_login/user_pass"
return JsonResponse({'status': 'not valid'}, status=400)
user_login = request.POST['user_login']
user_pass = request.POST['user_pass']
print "INF: check user: `{}' pass: `{}' in db".format(
user_login, user_pass)
try:
user = User.objects.get(username=user_login, password=user_pass)
except User.DoesNotExist:
print "ERR: not such user"
return JsonResponse({'status': 'not valid'}, status=401)
session_obj = SessionAuth.objects.create(cookie_token=generate_cookie(),
user=user)
response = JsonResponse({'status': 'valid'}, status=200)
response.set_cookie(SessionConf.cookie_token_key, session_obj.cookie_token)
response.set_cookie(SessionConf.cookie_user_key, session_obj.user.pk)
print "INF: created {}= `{}' and {}= `{}'".format(
SessionConf.cookie_token_key, session_obj.cookie_token,
SessionConf.cookie_user_key, session_obj.user.pk)
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 index(request):
response = JsonResponse({'foo':'bar'})
# Get the number of visits to the site.
# We use the COOKIES.get() function to obtain the visits cookie.
# If the cookie exists, the value returned is casted to an integer.
# If the cookie doesn't exist, we default to zero and cast that.
visits = request.session.get('visits')
reset_last_visit_time = False
# Does the cookie last_visit exist?
if 'last_visit' in request.COOKIES:
# Yes it does! Get the cookie's value.
last_visit = request.COOKIES['last_visit']
# Cast the value to a Python date/time object.
last_visit_time = datetime.strptime(last_visit[:-7], "%Y-%m-%d %H:%M:%S")
# If it's been more than a day since the last visit...
#if (datetime.now() - last_visit_time).days > 0:
visits = visits + 1
# ...and flag that the cookie last visit needs to be updated
reset_last_visit_time = True
else:
print('nenhuma visita anterior')
# Cookie last_visit doesn't exist, so flag that it should be set.
reset_last_visit_time = True
if reset_last_visit_time:
response.set_cookie('last_visit', datetime.now())
response.set_cookie('visits', visits)
# Return response back to the user, updating any cookies that need changed.
return response
def ajax_search(request, content):
if request.is_ajax():
contentList = processSQLSymbol(content)
print content
print contentList
questions = question.objects.none()
for item in contentList:
questions = questions | question.objects.filter(
title__contains=item)
print questions
questionJson = []
for q in questions:
temp = {}
temp['id'] = q.id
temp['title'] = q.title
temp['tag'] = q.tag
temp['content'] = q.content
try:
temp['time'] = q.time.strftime("%Y-%m-%d %H:%M")
except:
temp['time'] = q.time
temp['From'] = unicode(q.From)
answers = answer.objects.filter(questionid=q.id)
temp['answernumber'] = len(answers)
questionJson.append(temp)
response = JsonResponse({'_question': questionJson})
response.set_cookie('_searchcontent', content)
return response
else:
return HttpResponseRedirect('/')
def sdLogin(request, *args, **kwargs):
# TODO: Support the "next" parameter in the template javascript redirect code.
# This POST method is called by javascript and expects some JSON in return.
# The goal here is to authenticate the user with oauth and then encrypt the
# oauth information. The encrypted information will be stored in a browser cookie,
# to be later decrypted in the middleware level to set the "Authorization" header.
if request.method == 'POST':
if 'username' not in request.POST or 'password' not in request.POST:
raise ValueError
# Manually do django authentication.
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None and user.is_active:
# Log our user in to django
login(request, user)
# Create and encrypt the access token based on this user
enc = encrypt_access_token(create_access_token(user, user.profile.oauth_scope))
# Setup login redirect
if 'next' in request.GET:
redirect = request.GET['next']
else:
redirect = settings.LOGIN_REDIRECT_URL
# Format our response
response = JsonResponse(
dict([('status', 'OK'), ('next', redirect)])
)
# Set the encrypted token in the response.
response.set_cookie('token', enc.decode('UTF-8'))
response.set_cookie('fade-page-in', 1)
else:
# Send our error message
response = JsonResponse(
dict([('status', 'ERROR')])
)
return response
else:
form = accounts.forms.SDAuthenticationForm()
context = {
'form': form,
'next': request.GET['next'] if 'next' in request.GET else None,
}
return render(request, 'accounts/login.html', context)
def cookie_test(request):
# o = request.COOKIES['login_cookie']
# decrypted = crypto.decrypt(o,crypto.PRIVATE_KEY)
print request.COOKIES
print request.method
decrypted = "helloWorld"
resp = JsonResponse({})
resp.set_cookie("tempcokie","fdgfdgfdg",httponly=True,secure=True,max_age=30);
return resp
def authorize(r):
username, password = r.POST['username'], r.POST['password']
user = authenticate(username=username, password=password)
if user is None:
print('invalid username/password: {} and {}'.format(username, password))
return JsonResponse({'status': 'invalid'}, status=403)
resp = JsonResponse({'status': 'valid'})
auth = ClientAuthorization.objects.create(user=user)
resp.set_cookie('user_id', user.pk)
resp.set_cookie('token', auth.token)
return resp
def post(self, request):
check = CheckRequest(request);
uf = LoginForm(check.jsonForm)
if uf.is_valid():
groupId = uf.cleaned_data['groupId']
qq = uf.cleaned_data['qq']
password = db_password(uf.cleaned_data['password'])
# 获取的表单数据与数据库进行比较
admin = GroupAdmin.objects.filter(
groupId__exact=groupId,
qq__exact=qq,
password__exact=password
).first()
if admin:
if admin.userType == 1 and admin.status == 0:
return JsonResponse({
"status": 'error',
"msg": "群主帐号未激活"
})
data = {
"status": 'success',
'msg': "Login success"
}
admin_token = new_token(admin, 'login')
token = admin_token.get_token()
cookieOpt = admin_token.expired_time
data['cookies'] = {
'token': {
'value': token,
'opt': cookieOpt
}
}
response = JsonResponse(data)
response.set_cookie("admin_token",value=token, max_age=expiration['login'], httponly=True)
response.set_cookie("admin_logined",value="yes", max_age=expiration['login'])
return response
else:
# 用户名或密码错误
return JsonResponse({"status": 'error',
'msg': "GroupID or qq or password is error"
})
else:
return JsonResponse({"status": 'error',
'msg': "login form is error: %s" % uf.errors
})
def login(request):
if request.method == 'POST':
response_data = {}
try:
user = Users.objects.get(username = request.POST.get('accountnumber') , password = request.POST.get('password'))
except:
user = None
if user:
response_data['exist'] = True
response = JsonResponse(response_data)
response.set_cookie('account',request.POST.get('accountnumber'))
else:
response_data['exist'] = False
response = JsonResponse(response_data)
return response
def post(self, request):
check = CheckRequest(request);
uf = LoginForm(check.jsonForm)
if uf.is_valid():
qq = uf.cleaned_data['qq']
password = db_password(uf.cleaned_data['password'])
# 获取的表单数据与数据库进行比较
user = User.objects.filter(qq__exact=qq, password__exact=password).first()
if user:
if user.status == 1:
data = {"status": 'success',
'msg': "Login success"
}
user_token = new_token(user, 'login')
token = user_token.get_token()
cookieOpt = user_token.expired_time
data['cookies'] = {
'token': {
'value': token,
'opt': cookieOpt
}
}
response = JsonResponse(data)
response.set_cookie("token", value=token, max_age=expiration['login'], httponly=True)
response.set_cookie("logined", value="yes", max_age=expiration['login'])
return response
elif user.status == 0:
return JsonResponse({
"status" : 'success',
"code": 30004,
"msg": successCode[30004]
})
else:
return JsonResponse({
"status" : 'error',
'msg' : "用户状态不合法，请联系管理员"
})
else:
# 用户名或密码错误
return JsonResponse({"status": 'error',
'msg': "email or password is error"
})
else:
return JsonResponse({"status": 'error',
'msg': "login form is error"
})
def post(self, request):
if request.is_ajax():
# Extract values from the ajax POST request
session_key = request.COOKIES[settings.SESSION_COOKIE_NAME]
user_name = request.POST[HttpParameters.USERNAME.value]
otc = request.POST[HttpParameters.OTC.value] # One-time code from 2-factor authentication
password = request.POST[HttpParameters.PASSWORD.value]
hostname = request.POST[HttpParameters.HOSTNAME.value]
port = request.POST[HttpParameters.PORT.value]
source = request.POST[HttpParameters.SOURCE.value]
expiry_date = request.session.get_expiry_date()
socket = create_sftp_connection_socket()
socket.send_json({ZmqMessageKeys.ACTION.value: ZmqMessageValues.CONNECT.value,
ZmqMessageKeys.SESSION_KEY.value: session_key,
ZmqMessageKeys.USERNAME.value: user_name,
ZmqMessageKeys.OTC.value: otc,
ZmqMessageKeys.PASSWORD.value: password,
ZmqMessageKeys.HOSTNAME.value: hostname,
ZmqMessageKeys.PORT.value: port,
ZmqMessageKeys.SOURCE.value: source,
ZmqMessageKeys.EXPIRY.value: expiry_date.timestamp()})
resp_msg = socket.recv_json()
if ZmqMessageKeys.EXCEPTION.value in resp_msg:
socket.close()
return JsonResponse(resp_msg)
if ZmqMessageKeys.RESULT.value in resp_msg \
and resp_msg[ZmqMessageKeys.RESULT.value] == ZmqMessageValues.SUCCESS.value:
socket.send_json({ZmqMessageKeys.ACTION.value: ZmqMessageValues.LIST.value,
ZmqMessageKeys.SESSION_KEY.value: session_key,
ZmqMessageKeys.SOURCE.value: source})
resp_msg = socket.recv_json()
socket.close()
if ZmqMessageKeys.EXCEPTION.value in resp_msg:
# Don't set cookie
return JsonResponse(resp_msg)
if ZmqMessageKeys.DATA.value in resp_msg:
# Do set cookie
response = JsonResponse(resp_msg)
response.set_cookie(source, user_name)
return response
else:
return HttpResponseNotAllowed()
def post(self, request):
# 获取数据
sku_id = request.POST.get("sku_id") # 商品id
count = request.POST.get("count") # 修改之后的数量
# 检查数据
# 判断商品是否存在
try:
sku = GoodsSKU.objects.get(id=sku_id)
except GoodsSKU.DoesNotExist:
return JsonResponse({"code": 1, "message": "商品不存在"})
# count是否是整数
try:
count = int(count)
except Exception:
return JsonResponse({"code": 2, "message": "数量参数有问题"})
# 判断库存
if count > sku.stock:
return JsonResponse({"code": 3, "message": "库存不足"})
# 业务处理，保存数据
if not request.user.is_authenticated():
# 如果用户未登录，保存数据到cookie中
cart_json = request.COOKIES.get("cart")
if cart_json is not None:
cart = json.loads(cart_json)
else:
cart = {}
cart[sku_id] = count
response = JsonResponse({"code": 0, "message": "修改成功"})
response.set_cookie("cart", json.dumps(cart))
return response
else:
# 如果用户已登录，保存数据到redis中
redis_conn = get_redis_connection("default")
user_id = request.user.id
# cart = redis_conn.hgetall("cart_%s" % user_id)
# # 将sku_id转换为bytes，对redis返回的字典cart进行操作
# sku_id = sku_id.encode()
# cart[sku_id] = count
redis_conn.hset("cart_%s" % user_id, sku_id, count)
# 返回结果， 返回Json数据
return JsonResponse({"code": 0, "message": "修改成功"})
def validate_registration(request):
if request.method == 'POST':
validationCode = request.POST.get('validationCode')
username = request.POST['username']
user = User.objects.get(username=username)
appUser = AppUser.objects.get(user=user)
if appUser.validationCode == validationCode:
appUser.validated = True
appUser.save()
isValidated = appUser.validated
status = {'status_code' : '200' , 'isValidated': isValidated}
response = JsonResponse(status)
response.set_cookie('username' , username)
return response
else:
wrong_token = 'Wrong Token'
return JsonResponse({'error' : wrong_token, 'username': username , 'validationCode':validationCode})
def create_new_activity_1(request):
form = ActivityCreationForm(request.user, initial={"host_name": request.user.profile.name})
if request.method == "POST":
form = ActivityCreationForm(request.user, request.POST, request.FILES)
if form.is_valid():
act = form.save()
# request.COOKIES["activity_creation_info"] = \
# get_activity_session_representation(act)
# request.COOKIES.set_expiry(1800) # 这个session只有在三十分钟内有效
response = JsonResponse({
"success": True,
"data": {
"url": "/action/%s/create/2" % act.id
}
}, content_type='text/html')
response.set_cookie("activity_creation_info", get_activity_session_representation(act),
max_age=1800)
return response
else:
logger.debug(u"创建活动失败，失败信息为: %s" % form.errors.as_data)
data = {}
errors = form.errors
if 'start_time' in errors:
data['start_time'] = u'开始时间不能早于当前时间'
if 'end_time' in errors:
data['end_time'] = u'结束时间不能早于开始时间'
if data == {}:
data['unknown'] = u'未知错误'
return JsonResponse({
"success": False,
"data": data
}, content_type='text/html')
args = {}
args.update(csrf(request))
args["form"] = form
activity_type = ActivityType.objects.all()
args["types"] = activity_type
return render(request,
choose_template_by_device(request,
"Activity/create-action-1.html",
"Activity/mobile/create-action-1.html"),
args)
def login_check(request):
'''登录功能的实现:
*如果返回状态1 代表能够登录成功
*如果返回状态2 代表登录用户名错误
*如果返回状态3 代表密码错误
'''
username = request.POST.get('username')
password = request.POST.get('password')
secret_password = get_hash(password)
passport = PassPort.objects.getPassPort(username)
# 如果数据库里没有这个用户名
if PassPort.objects.check_user_exist(username) == False:
data = {'state':2}
jre = JsonResponse(data)
# 密码正确 能够成功登录
elif passport.password == secret_password :
#如果登录之前用户访问过某个页面，我们登录过后再跳回原来的页面
if request.session.has_key('pre_url_path'):
next = request.session.get('pre_url_path')
else:
next = '/index/'
data = {
'state':1,
'username':username,
'next':next,
}
jre = JsonResponse(data)
# 如果点击了记住用户名，就设置cookie
if request.POST.get('remember_user') == "true" :
jre.set_cookie('username',username,max_age=7*24*60*60 )
#记住用户登录的状态
request.session['islogin'] = True
request.session['username'] = username
request.session['passport_id'] = passport.id
# 如果密码不正确
else :
data = {'state': 3}
jre = JsonResponse(data)
return jre
def refresh(request):
# Get default client
client_idx = request.session.get('op')
if client_idx:
client = CLIENTS[client_idx]
else:
client = CLIENTS[list(settings.OIDC_PROVIDERS)[0]]
try:
refresh_token = request.GET.get('refresh_token') or request.COOKIES.get('REFRESH_TOKEN') \
or request.session.get('refresh_token')
if refresh_token is None:
return HttpResponseBadRequest("No refresh token found.")
tokens = client.refresh_access_token(request.session, refresh_token)
response = JsonResponse(tokens)
response.set_cookie("ACCESS_TOKEN", tokens['access_token'])
response.set_cookie("REFRESH_TOKEN", tokens['refresh_token'])
except OIDCError as error:
return HttpResponseForbidden(error)
return response
def login_page(request):
"""
View login pages, which consist with enter card number and pin.
"""
if request.POST and request.is_ajax():
# when enter card number
number = request.POST.get('number', None)
if number:
number = int('{0}{1}{2}{3}'.format(*number.split('-')))
card = User.objects.filter(card_number=int(number)).first()
response = check_existence(card)
if not response['success']:
return JsonResponse(response)
response = check_is_active(card)
if not response['success']:
return JsonResponse(response)
response = JsonResponse(response)
response.set_cookie('number', value=card.card_number, httponly=True)
return response
# when enter card pin
pin = request.POST.get('pin', None)
if pin:
number = request.COOKIES.get('number')
card = User.objects.filter(card_number=int(number)).first()
auth = authenticate(card_number=card.card_number, password=pin)
response = check_auth(card, auth)
if not response['success']:
return JsonResponse(response)
login(request, auth)
card.attempts = 0
card.save()
response = JsonResponse(
{"success": True, "redirect": reverse('operations')})
return response
return render(request, 'login_page.html', {})
def auth_user(request):
if 'user_login' not in request.POST or 'user_pass' not in request.POST:
print "ERR: no fields user_login/user_pass"
return JsonResponse({'status': 'not valid'}, status=400)
user_login = request.POST['user_login']
user_pass = request.POST['user_pass']
print "INF: check user: `{}' pass: `{}' in db".format(user_login, user_pass)
try:
user = User.objects.get(username=user_login, password=user_pass)
except User.DoesNotExist:
print "ERR: not such user"
return JsonResponse({'status': 'not valid'}, status=401)
session_obj = SessionAuth.objects.create(cookie_token=generate_cookie(), user=user)
response = JsonResponse({'status': 'valid'}, status=200)
response.set_cookie(SessionConf.cookie_token_key, session_obj.cookie_token)
response.set_cookie(SessionConf.cookie_user_key, session_obj.user.pk)
print "INF: created {}= `{}' and {}= `{}'".format(SessionConf.cookie_token_key, session_obj.cookie_token,
SessionConf.cookie_user_key, session_obj.user.pk)
return response
def login(request):
if request.method == 'POST':
if username in request.COOKIES:
username = request.COOKIES['username']
user = authenticate(username=username, password=username)
if user:
login(request, user)
status = {'status_code' : '200'}
return JsonResponse(status)
else:
status = {'status' : 'False'}
else:
username = request.POST['username']
user = authenticate(username=username, password=username)
if user:
login(request, user)
status = {'status_code' : '200'}
response = JsonResponse(status)
response.set_cookie('username', username)
return response
else:
status = {'status' : 'False'}
return JsonResponse(status)
def post(self, request):
# # 判断用户是否登录
# if not request.user.is_authenticated():
# # 表示用户未登录
# return JsonResponse({"code": 1, "message": "用户未登录"})
# sku_id 商品id
# count 商品数量
# 接受参数
sku_id = request.POST.get("sku_id")
count = request.POST.get("count")
# 校验参数
if not all([sku_id, count]):
return JsonResponse({"code": 2, "message": "参数不完整"})
# 判断商品存在与否
try:
sku = GoodsSKU.objects.get(id=sku_id)
except GoodsSKU.DoesNotExist:
# 表示商品不存在
return JsonResponse({"code": 3, "message": "商品不存在"})
# 判断用户请求的count是不是整数
try:
count = int(count)
except Exception:
# 数量不是整数
return JsonResponse({"code": 4, "message": "参数错误"})
# 判断数量有没有超过库存
if count > sku.stock:
return JsonResponse({"code": 5, "message": "库存不足"})
# 业务逻辑处理，
if request.user.is_authenticated():
user_id = request.user.id
# 如果用户登录，将数据保存到redis中
# "cart_user_id": {"sku_1": 10, "sku_2": 20}
redis_conn = get_redis_connection("default")
# 先从redis中尝试获取用户原有购物车中相同商品的信息
user_id = request.user.id
origin_count = redis_conn.hget("cart_%s" % user_id, sku_id)
# 如果redis中不存在，则直接将数据保存到redis的购物车中
# 如果redis中原本包含了这个商品的数量信息， 进行数量累加，在保存到redis中
if origin_count is not None:
count += int(origin_count)
redis_conn.hset("cart_%s" % user_id, sku_id, count)
# 计算购物车中最新的总数
cart_num = 0
cart = redis_conn.hgetall("cart_%s" % user_id)
# {"sku_id": "10", "sku_id": "11"}
for val in cart.values():
cart_num += int(val)
# 通过返回json数据，告知前端处理的结果
return JsonResponse({"code": 0, "message": "添加购物车成功", "cart_num": cart_num})
else:
# 如果用户未登录，则将数据保存到cookie中
# 先获取用户的cookie中的购物车数据
cart_json = request.COOKIES.get("cart")
if cart_json is not None:
# 用户的cookie中有购物车数据
cart = json.loads(cart_json) # 将json字符串转换为字典
else:
# 用户的cookie中原本没有购物车数据
cart = {}
# {"sku_id": 10, "sku_id": 11}
if sku_id in cart: # 判断键是否存在
# 如果购物车数据中包含了这个商品，则进行数量求和
origin_count = cart[sku_id] # 原有的数量
count += origin_count
# 在购物车的字典数据中保存这个商品的信息
cart[sku_id] = count
# 再最新的商品数量添加到cookie的购物车数据中
new_cart_json = json.dumps(cart) # 将字典转换为json字符串
# 统计购物车中的商品总数
cart_num = 0
for val in cart.values():
cart_num += val
# 构造返回的JsonResponse对象，再设置cookie
response = JsonResponse({"code": 0, "message": "添加购物车成功", "cart_num": cart_num})
response.set_cookie("cart", new_cart_json)
return response
