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