def post(self, request):
username = request.POST.get('username')
password = request.POST.get('password')
us = UserModel.objects.filter(username=username)
# form表单操作~~~~~~
form = LoginForm(data=request.POST)
if not form.is_valid():
return HttpResponse('账户或密码错误')
us = UserModel.objects.filter(username=form.cleaned_data['username'])
if not us.exists():
return HttpResponse('用户不存在')
if us.first().password != password:
return HttpResponse("密码错误")
# cookies
response = HttpResponse('登录成功')
response.set_cookie('uid', us.first().id) #
print(us.first().id)
response.set_cookie('name', us.first().username) #
print(response.set_cookie('name', us.first().username))
# session
# 不能直接使用us.first().id、需要加一个前缀'test' + str(us.first().id)
request.session['test' + str(us.first().id)] = us.first().username
return response
def set_cookie(request):
print(request.COOKIES)
res = HttpResponse()
res.content = '我已经设置好了cookie!!!'
res.status_code = 200
res.set_cookie('name', value='lisi', max_age=30)
return res
def run(self):
if self.input_Request.GET.get("unlogin")!=None:
return self.unlogin()
beijing={"id":1,"name":"北京"}
shanghai={"id":2,"name":"上海"}
userAreas=[beijing,shanghai]
dataset={"result":"","areas":userAreas}
if self.input_Request.method=="POST":
getUserName=self.input_Request.POST.get("txtUserName")
getUserPass=self.input_Request.POST.get("txtUserPass")
Login_result=self.login(getUserName,getUserPass)
if Login_result:
myResponse=HttpResponse("<script>self.location='/index/index'</script>")
myResponse.set_cookie("userlogin_username",getUserName,3600)
return myResponse
else:
dataset["result"]="用户名和密码错误"
myResponse=render_to_response("userlogin.html",dataset)
return render_to_response("userlogin.html",dataset)
def post(self, request):
username = request.POST.get('username', '')
password = request.POST.get('password', '')
user = UserProfile.objects.filter(Q(email=username)|Q(phone=username))
if user:
user = UserProfile.objects.filter(Q(email=username)|Q(phone=username) , password=password)
if user:
data = serializers.serialize('json', user, fields=('nick_name', 'gender', 'email', 'phone',
'avatar', 'school', 'city', 'level', 'state'))
response = HttpResponse(data, content_type="application/json")
cookies = user.values('uuid')[0].get('uuid')
response.set_cookie('AccessToken', cookies, max_age=259200)
return response
else:
res = {
'StatusCode': 102,
'detail': '请检测密码是否正确'
}
return HttpResponse(json.dumps(res), content_type="application/json")
else:
res = {
'StatusCode': 101,
'detail': '请检测用户名是否正确'
}
return HttpResponse(json.dumps(res), content_type="application/json")
def signup(self, request, *args, **kwargs):
serializer = UsrCreateSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
userId = request.data.get('userId')
password = hashlib.sha256(
request.data.get('password').encode()).hexdigest()
userName = request.data.get('userName')
email = request.data.get('email')
try:
Usr.objects.raw(
f'SELECT * FROM (SELECT * FROM USR WHERE USR_ID=\'{userId}\') WHERE ROWNUM=1;'
)[0]
except IndexError:
with connection.cursor() as cursor:
cursor.execute(
"INSERT INTO USR (USR_ID, USR_PASSWORD, USR_EMAIL, USR_NAME) " \
f"VALUES ('{userId}', '{password}', '{email}', '{userName}');"
)
res = {
'userId': userId,
'userName': userName,
'email': email,
'isAdmin': False
}
token = jwt.encode(res, settings.SECRET_KEY,
settings.ALGORITHM).decode('utf-8')
# response = JsonResponse(res, status=201)
response = HttpResponse(status=201)
response.set_cookie('jwt', token, httponly=False)
return response
return Response(status=409, data='이미 존재하는 아이디입니다.')
def uregister(req):
msg = None
if req.method == "POST":
username = req.POST['username']
pwd = req.POST['pwd']
pwd2 = req.POST['pwd2']
name_len = len(username)
if name_len < 5 or name_len > 12:
return HttpResponse(U_P_ERR, content_type='application/json')
if pwd == pwd2 and pwdptn.match(pwd):
try:
with transaction.atomic(None, False):
obj = u.create_user(username=username, password=pwd)
obj.save()
except IntegrityError as err:
msg = U_RPT_ERR
except Exception as err:
msg = SVR_ERR
if msg:
return HttpResponse(msg, content_type='application/json')
login(req, obj)
rsp = HttpResponse('"' + uname_m_fname(username) + '"',
content_type='application/json')
rsp.set_cookie('login', 1, secure=False)
return rsp
else:
return HttpResponse(U_P_ERR, content_type='application/json')
def process_response(self, request: HttpRequest,
response: HttpResponse) -> HttpResponse:
"""
If request.session was modified, or if the configuration is to save the
session every time, save the changes and set a session cookie or delete
the session cookie if the session has been emptied.
"""
try:
accessed = request.session.accessed
modified = request.session.modified
empty = request.session.is_empty()
except AttributeError:
return response
# Set SameSite based on whether or not the request is secure
secure = SessionMiddleware.is_secure(request)
same_site = "None" if secure else "Lax"
# First check if we need to delete this cookie.
# The session should be deleted only if the session is entirely empty.
if settings.SESSION_COOKIE_NAME in request.COOKIES and empty:
response.delete_cookie(
settings.SESSION_COOKIE_NAME,
path=settings.SESSION_COOKIE_PATH,
domain=settings.SESSION_COOKIE_DOMAIN,
samesite=same_site,
)
patch_vary_headers(response, ("Cookie", ))
else:
if accessed:
patch_vary_headers(response, ("Cookie", ))
if (modified or settings.SESSION_SAVE_EVERY_REQUEST) and not empty:
if request.session.get_expire_at_browser_close():
max_age = None
expires = None
else:
max_age = request.session.get_expiry_age()
expires_time = time() + max_age
expires = http_date(expires_time)
# Save the session data and refresh the client cookie.
# Skip session save for 500 responses, refs #3881.
if response.status_code != 500:
try:
request.session.save()
except UpdateError:
raise SessionInterrupted(
"The request's session was deleted before the "
"request completed. The user may have logged "
"out in a concurrent request, for example.")
response.set_cookie(
settings.SESSION_COOKIE_NAME,
request.session.session_key,
max_age=max_age,
expires=expires,
domain=settings.SESSION_COOKIE_DOMAIN,
path=settings.SESSION_COOKIE_PATH,
secure=secure,
httponly=settings.SESSION_COOKIE_HTTPONLY or None,
samesite=same_site,
)
return response
def cookie_demo(request):
"""演示cookie读写"""
# 设置cookie
response = HttpResponse("cookie_demo")
# 设置cookie set_cookie(key, value, 过期时间单秒(秒))
response.set_cookie("name", "jack", max_age=3600)
# 读取cookie,cookie 存在浏览器端
print(request.COOKIES.get("name"))
return response
def get(self, request):
"""Void view to set a csrftoken Cookie"""
token = get_token(request)
response = HttpResponse()
response.set_cookie('csrftoken', value=token)
# response = HttpResponse(
# content=json.dumps({'csrftoken': token}),
# content_type='application/json')
return response
def setCookie(request):
resp = HttpResponse("Cookie setted")
resp.set_cookie('userName', request.META['LOGNAME'])
resp.set_cookie('email', request.META['EMAIL_USER'])
print(resp)
return resp
def index(request):
response = HttpResponse('hello,xiaobai')
response.set_cookie('best2','python3',max_age=3000)
response.set_cookie('best5','python6',max_age=3000)
cookie2 = request.COOKIES.get('best2')
print(cookie2)
cookie3 = response.delete_cookie('best2')
return response
def post(self, request):
if not hasattr(request, "user") or not request.user.is_authenticated:
return HttpResponse("Invalid token", status=401)
else:
response = HttpResponse()
# secure=not settings.DEBUG so that we do not need https when developing
response.set_cookie("AuthToken",
str(request.auth),
secure=not settings.DEBUG,
httponly=True)
return response
def process_middleware(self) -> HttpResponse:
# send request and response through middleware
returned = CookieCheckMiddleware.process_request(self.r)
# if returned is a response, use that in process_response. If not make a new response object
if isinstance(returned, HttpResponse):
response = returned
else:
response = HttpResponse()
if self.set_session_id:
response.set_cookie("sessionid", "test")
response = CookieCheckMiddleware.process_response(self.r, response)
return response
def cookie_msg(request):
# set_cookie
response = HttpResponse('设置cookie')
# HttpResponse.set_cookie('itcast','tanwen',max_age=30) # max_age=30 时间为秒 静态方法
response.set_cookie('itcast','tanwen')
# 获取COOKIE值
cookie = request.COOKIES
print(cookie)
print(type(cookie)) # 字典
print(cookie['itcast']) # 取value值
return response
def post(self, request):
p_form = ProfileUpdateForm(request.POST,
request.FILES,
instance=request.user.profile)
u_form = UserUpdateForm(request.POST, instance=request.user)
if p_form.is_valid() and u_form.is_valid():
u_form.save()
p_form.save()
messages.success(request, 'Your Profile has been updated!')
translation.activate(request.user.profile.language_code)
response = HttpResponse('profile')
response.set_cookie(settings.LANGUAGE_COOKIE_NAME,
request.user.profile.language_code)
return redirect('profile')
def setting_cookie(request):
resp = HttpResponse() # $ HttpResponse mimetype=text/html
resp.set_cookie(
"key", "value") # $ CookieWrite CookieName="key" CookieValue="value"
resp.set_cookie(
key="key",
value="value") # $ CookieWrite CookieName="key" CookieValue="value"
resp.headers[
"Set-Cookie"] = "key2=value2" # $ MISSING: CookieWrite CookieRawHeader="key2=value2"
resp.cookies[
"key3"] = "value3" # $ CookieWrite CookieName="key3" CookieValue="value3"
resp.delete_cookie("key4") # $ CookieWrite CookieName="key4"
resp.delete_cookie(key="key4") # $ CookieWrite CookieName="key4"
return resp
def FetchNewData(request):
records = Record.objects.all().order_by('-time');
newNum = len(records);
length = int(request.COOKIES.get('length',0))
r = newNum - length
print newNum,' ',length
print r
data = records[:r]
print data
funny_page = render_to_string('downloadApp/data_bysi.html', {"records": data})
context = json.dumps(funny_page)
response = HttpResponse(context)
response.set_cookie('length',newNum)
return response
def set_color(request):
if "favorite_color" in request.GET:
# Create an HttpResponse object...
response = HttpResponse("Your favorite color is now %s" %
request.GET["favorite_color"])
# ... and set a cookie on the response
response.set_cookie("favorite_color",
request.GET["favorite_color"])
return response
else:
return HttpResponse("You didn't give a favorite color.")
def get(self, request, *args, **kwargs):
response = HttpResponse('', content_type='text/javascript')
try:
message = self.decrypt_payload(
urlsafe_base64_decode(kwargs.get('message')))
is_session_empty = request.session.is_empty()
# replace session cookie only when session is empty or when always replace is set
if is_session_empty or getattr(
settings, 'SHARED_SESSION_ALWAYS_REPLACE', False):
http_host = request.META['HTTP_HOST']
if (timezone.now() -
parse(message['ts'])).total_seconds() < getattr(
settings, 'SHARED_SESSION_TIMEOUT', 30):
if request.session.get_expire_at_browser_close():
max_age = None
expires = None
else:
max_age = request.session.get_expiry_age()
expires_time = time.time() + max_age
expires = cookie_date(expires_time)
response.set_cookie(
settings.SESSION_COOKIE_NAME,
message['key'],
max_age=max_age,
expires=expires,
domain=settings.SESSION_COOKIE_DOMAIN,
path=settings.SESSION_COOKIE_PATH,
secure=settings.SESSION_COOKIE_SECURE or None,
httponly=settings.SESSION_COOKIE_HTTPONLY or None,
)
# ensure CSRF cookie is set
get_token(request)
# emit signal
signals.session_replaced.send(sender=self.__class__,
request=request,
was_empty=is_session_empty,
src_domain=message['src'],
dst_domain=http_host)
except (CryptoError, ValueError):
pass
return response
def to_djangoresponse(self):
"""django用のレスポンス.
"""
content_type = self.__headers.get('content-type', 'text/plain')
self.set_header('content-length', str(len(self.__body)))
django_response = DjangoHttpResponse(self.__body, content_type=content_type, status=self.status)
for k, v in self.__headers.items():
django_response[k] = v
if self.status == 301:
django_response = HttpResponsePermanentRedirect(django_response.get('location'))
elif self.status == 302:
django_response = HttpResponseRedirect(django_response.get('location'))
for k, arr in self.__cookies.items():
v, expires, domain = arr
django_response.set_cookie(k, v, expires=expires, domain=domain)
return django_response
def article_view(request, article_id):
context = {}
try:
article = Article.objects.get(pk=article_id)
if "art_%s_read" % article_id not in request.COOKIES:
article.read_num += 1
article.save()
except Article.DoesNotExist:
return render(request, "blog/article_v1.html", context=context)
context['article'] = article
content = loader.render_to_string("blog/article_v1.html", context=context, request=request)
response = HttpResponse(content)
response.set_cookie("art_%s_read" % article_id, "True")
return response
def checkout_existing_invoice(request,
invoice,
lines,
return_url_ns='public_booking_success',
return_preload_url_ns='public_booking_success',
invoice_text=None,
vouchers=[],
proxy=False):
#basket_params = {
# # 'products': invoice.order.basket.lines.all(),
# 'products': lines,
# 'vouchers': vouchers,
# 'system': settings.PAYMENT_SYSTEM_ID,
# 'custom_basket': True,
#}
basket, basket_hash = use_existing_basket_from_invoice(invoice.reference)
checkout_params = {
'system': settings.PAYMENT_SYSTEM_ID,
'fallback_url': request.build_absolute_uri('/'),
'return_url': request.build_absolute_uri(reverse(return_url_ns)),
'return_preload_url':
request.build_absolute_uri(reverse(return_url_ns)),
'force_redirect': True,
'invoice_text': invoice.text,
}
create_checkout_session(request, checkout_params)
# response = HttpResponseRedirect(reverse('checkout:index'))
# use HttpResponse instead of HttpResponseRedirect - HttpResonseRedirect does not pass cookies which is important for ledger to get the correct basket
response = HttpResponse("<script> window.location='" +
reverse('checkout:index') +
"';</script> <a href='" +
reverse('checkout:index') +
"'> Redirecting please wait: " +
reverse('checkout:index') + "</a>")
# inject the current basket into the redirect response cookies
# or else, anonymous users will be directionless
response.set_cookie(settings.OSCAR_BASKET_COOKIE_OPEN,
basket_hash,
max_age=settings.OSCAR_BASKET_COOKIE_LIFETIME,
secure=settings.OSCAR_BASKET_COOKIE_SECURE,
httponly=True)
return response
def get(self, request):
invalid_response = self.is_valid(request)
if invalid_response:
return invalid_response
if not self.client.path_valid(request.GET.get(
'pth', '')) or not self.client.ip_valid(self.client_ip):
return HttpResponse(status=204) # NO_CONTENT
tracking_id = request.GET.get('dti',
request.session.get('dja_tracking_id'))
user_id = request.GET.get('du', request.COOKIES.get('dja_uuid'))
data = {
'domain': self.parsed_url.netloc,
'protocol': self.parsed_url.scheme,
'client': self.client,
'ip_address': self.client_ip,
'user_agent': request.META.get('HTTP_USER_AGENT', 'None'),
'path': request.GET.get('pth', ''),
'query_string': request.GET.get('qs', ''),
'referrer': request.GET.get('rf', '')[:2083],
'screen_width': request.GET.get('sw'),
'screen_height': request.GET.get('sh'),
}
status = 201 # CREATED
if tracking_id:
data['tracking_key'] = tracking_id
status = 202 # ACCEPTED
if user_id:
data['tracking_user_id'] = user_id
status = 202 # ACCEPTED
new_event = models.RequestEvent.objects.create(**data)
if not tracking_id:
request.session['dja_tracking_id'] = new_event.tracking_key
with open(os.path.join(TRACKING_PIXEL_PATH, 'tracking_pixel.png'),
'rb') as f:
img_data = f.read()
response = HttpResponse(content=img_data,
status=status,
content_type='image/png')
response.set_cookie('dja_uuid',
new_event.tracking_user_id,
expires=datetime.now() + timedelta(days=365))
return response
def ulogin(req):
if req.method == "POST":
username = req.POST['username']
pwd = req.POST['pwd']
ip = req.META['REMOTE_ADDR']
#cron event will be triggered everyhour
try:
rec = IPRecord.objects.get(ip=ip)
except Exception:
rec = None
if rec and rec.failure_times > 4:
return HttpResponse(IP_FORBID, content_type='application/json')
user = authenticate(req, username=username, password=pwd)
msg = None
if user is None:
if rec:
if rec.failure_times == 4:
date_aval = round(t()) + ONEDAY
with transaction.atomic(None, False):
rec.failure_times += 1
rec.date_available = date_aval
rec.save()
else:
with transaction.atomic(None, False):
rec.failure_times += 1
rec.save()
else:
date_aval = round(t()) + ONEDAY
with transaction.atomic(None, False):
rec = IPRecord.objects.create(ip=ip,
failure_times=1,
date_available=date_aval)
rec.save()
return HttpResponse(U_P_ERR, content_type='application/json')
else:
login(req, user)
fname = uname_m_fname(username)
rsp = HttpResponse('"' + fname + '"',
content_type='application/json')
# secure 是否仅通过https传输
rsp.set_cookie('login', fname[:CHK_LEN], secure=False)
return rsp
def post(self, request, *args, **kwargs):
'''
Log the person in. Login requires the following json to work:
{
"email" : "<email>",
"password" : "<password>"
}
'''
try:
session_id = authenticate(request)
resp = HttpResponse(request, status=204)
resp.set_cookie("sessionid", session_id, max_age=30)
return resp
except (KeyError, ValueError) as e:
return err(e)
except AuthenticationError as ae:
return err(ae, 401)
def get(self, request):
invalid_response = self.is_valid(request)
if invalid_response:
return invalid_response
if not self.client.path_valid(
request.GET.get('pth', '')
) or not self.client.ip_valid(self.client_ip):
return HttpResponse(status=204) # NO_CONTENT
tracking_id = request.GET.get(
'dti', request.session.get('dja_tracking_id')
)
user_id = request.GET.get(
'du', request.COOKIES.get('dja_uuid')
)
data = {
'domain': self.parsed_url.netloc,
'protocol': self.parsed_url.scheme,
'client': self.client,
'ip_address': self.client_ip,
'user_agent': request.META.get('HTTP_USER_AGENT', 'None'),
'path': request.GET.get('pth', ''),
'query_string': request.GET.get('qs', ''),
'referrer': request.GET.get('rf', '')[:2083],
'screen_width': request.GET.get('sw'),
'screen_height': request.GET.get('sh'),
}
status = 201 # CREATED
if tracking_id:
data['tracking_key'] = tracking_id
status = 202 # ACCEPTED
if user_id:
data['tracking_user_id'] = user_id
status = 202 # ACCEPTED
new_event = models.RequestEvent.objects.create(**data)
if not tracking_id:
request.session['dja_tracking_id'] = new_event.tracking_key
img_data = file(os.path.join(TRACKING_PIXEL_PATH, 'tracking_pixel.png')).read()
response = HttpResponse(content=img_data, status=status, content_type='image/png')
response.set_cookie('dja_uuid', new_event.tracking_user_id,
expires=datetime.now() + timedelta(days=365))
return response
def plan_list(request):
'''
巡检计划的展示页面
'''
logger.info(u'查看巡检计划')
q_system = ''
try:
q_system = request.REQUEST['system']
except:
q_system = request.COOKIES["system"]
cur_system_instance = System.objects.get(name=q_system)
tasks = Task.objects.filter(system=cur_system_instance)
plans = Plan.objects.filter(task__in=tasks)
context = {'plans': plans}
t = get_template('plans.html')
html = t.render(context)
response = HttpResponse(html)
response.set_cookie("system", q_system)
return response
def plan_list(request):
'''
巡检计划的展示页面
'''
logger.info(u'查看巡检计划')
q_system = ''
try:
q_system=request.REQUEST['system']
except:
q_system = request.COOKIES["system"]
cur_system_instance = System.objects.get(name=q_system)
tasks = Task.objects.filter(system=cur_system_instance)
plans = Plan.objects.filter(task__in=tasks)
context = {'plans': plans}
t = get_template('plans.html')
html = t.render(context)
response = HttpResponse(html)
response.set_cookie("system",q_system)
return response
def home_page(request):
# print request.session.keys['']
print request.user.is_authenticated()
res = HttpResponse("<html><body>this is books home page..</body></html>")
if request.session.test_cookie_worked():
session_id = request.COOKIES['sessionid']
print session_id
session = Session.objects.get(session_key=session_id)
print session.session_data
print session.get_decoded()
# request.session.delete_test_cookie()
res = HttpResponse('cookie is worked.')
return res
else:
request.session.set_test_cookie()
res = HttpResponse('open cookie.')
res.set_cookie('mykey', 'myvalue')
return res
return res
def home_page(request):
# print request.session.keys['']
print request.user.is_authenticated()
res = HttpResponse("<html><body>this is books home page..</body></html>")
if request.session.test_cookie_worked():
session_id = request.COOKIES['sessionid']
print session_id
session = Session.objects.get(session_key=session_id)
print session.session_data
print session.get_decoded()
# request.session.delete_test_cookie()
res = HttpResponse('cookie is worked.')
return res
else:
request.session.set_test_cookie()
res = HttpResponse('open cookie.')
res.set_cookie('mykey', 'myvalue')
return res
return res
def track_get_image(request):
image_data = open("images/transparent.gif", "rb").read()
response = HttpResponse(image_data, content_type="image/gif")
referer = request.META.get('HTTP_REFERER')
if not referer:
return response
visitor_id = request.COOKIES.get(COOKIE_NAME)
if not visitor_id:
visitor_id = create_visitor_id()
response.set_cookie(COOKIE_NAME, value=visitor_id, max_age=COOKIE_AGE)
page = get_page_from_url(referer)
log_pageview(page, visitor_id)
return response
def get(self, request, image_code_id):
#获取用户请求的图片验证码id
image_code_id = image_code_id
# 生成图片验证码和图片验证内容
text, image = captcha.generate_captcha()
print(text)
#将图片保存到redis数据库并设置有效期，用于后面验证
#连接redis数据库 get_redis_connection()参数为为redis的配置名 返回连接对象
redis_conn = get_redis_connection("verification")
#保存到redis数据库
redis_conn.setex('img_%s' % image_code_id,
constant.IMAGE_CODE_REDIS_EXPIRES, text)
test_conn = get_redis_connection("default")
#sting
str1 = test_conn.get('name')
print('type>>', type(str1), str1)
#list
list1 = test_conn.lrange('list1', 0, -1)
print('type>>', type(list1), list1)
#hash
obj1 = test_conn.hget('set1', 'name')
obj2 = test_conn.hgetall('set1')
print('type>>', type(obj1), obj1)
print('type>>', type(obj2), obj2)
#set
set1 = test_conn.smembers('obj')
print('type>>', type(set1), set1)
# 固定返回验证码图片数据，不需要REST framework框架的Response帮助我们决定返回响应数据的格式
# 所以此处直接使用Django原生的HttpResponse即可
#返回图片验证码
response = HttpResponse(image, content_type='images/jpg')
response.set_cookie('id', 'xxx', max_age=60)
return response
def index(request, *args, **kwargs):
if models.Setting.getvalue('installed') != 'True':
return HttpResponseRedirect('/install/')
template = loader.get_template('index.html')
server_type = models.Setting.getvalue('server_type')
server_name = models.Setting.getvalue(server_type)
html_title = models.Setting.getvalue('html_title')
context = {
'title': html_title or u'噢易班班通管理分析系统',
'server_type': server_type,
'server_name': server_name,
'query': request.GET
}
response = HttpResponse(template.render(context))
try:
o = models.Setting.objects.get(name='show_download_btn')
show_download_btn = str(o.value).lower()
except Exception:
show_download_btn = 'true'
if server_type == 'school':
show_download_btn = 'true'
response.set_cookie("show_download_btn", show_download_btn)
return response
def post(self, *args, **kwargs):
response = HttpResponse(json.dumps({'status': 'success'}), content_type='application/json')
message = get_object_or_404(models.Message, pk=int(self.request.POST.get('id')))
if self.request.user.is_authenticated():
try:
rel = models.MessageToUser.objects.get(user=self.request.user, message=message)
except models.MessageToUser.DoesNotExist:
rel = models.MessageToUser(user=self.request.user, message=message)
rel.viewed = True
rel.save()
else:
viewed = [unicode(message.pk)]
in_cookies = self.request.COOKIES.get('djxami', None)
if in_cookies and len(in_cookies) < 1000:
viewed += in_cookies.split(':')
print viewed
response.set_cookie('djxami',
str(':'.join(set(viewed))),
expires=now() + timedelta(days=365),
domain=settings.SESSION_COOKIE_DOMAIN,
secure=settings.SESSION_COOKIE_SECURE or None)
return response
def cookie_demo(request):
if 'name' in request.COOKIES:
cookie_id = request.COOKIES['city']
return HttpResponse('Got cookie with id=%s' % cookie_id)
else:
resp = HttpResponse('No id cookie! Sending cookie to client')
resp.set_cookie('name', "Kevin")
resp.set_cookie('age', "28")
resp.set_cookie('city', "USA")
return resp
def set_cookie(request):
t = request.GET.get('type')
print(type(t))
t = int(t)
template = loader.get_template("test_cookie.html")
response = HttpResponse(template.render())
if t == 1: # 设置key-valuecookie
from urllib import parse
s = parse.quote("Hello!@#$$%^& World, 上海sxt", encoding="utf-8")
response.set_cookie("test_cookie", s)
elif t == 2: # 设置过期时间
response.set_cookie("cookie_max_age", 123, max_age=10)
elif t == 3: #设置expires,会让max_age无效
import datetime
response.set_cookie("cookie_expires",
234,
max_age=10000,
expires=datetime.datetime(2020, 12, 1))
elif t == 4: # 设置path,只能在设置的路劲下访问，不同路径下key相同也是两个cookie, path默认/是根路径都可以访问
response.set_cookie("cookie_path1", 1234, path="/polls/redirectTest2/")
elif t == 5: # 设置域名，只能在当前域名下访问，如果是顶级域名，那么子域名下都能访问
response.set_cookie("cookie_domain", 3455, domain="www.shsxt.com")
elif t == 6: # 设置安全secure，只能在https中进行测试
response.set_cookie("cookie_secure", 333, secure=True)
elif t == 7: # 设置httponly，不能用js操作cookie
response.set_cookie("cookie_httponly", 3443, httponly=True)
else: # 使用set_signed_cookie()是给cookie的value加密，要穿如salt
response.set_signed_cookie("cookie_sign", 3234234, salt="shsxt")
return response
def auth_csrf(request):
ctkn = unicode(csrf(request)['csrf_token'])
response = HttpResponse(status=204)
response.set_cookie("csrftoken", ctkn)
return response
