def test_detects_tampering(self):
response = HttpResponse()
response.set_signed_cookie('c', 'hello')
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value[:-2] + '$$'
self.assertRaises(signing.BadSignature,
request.get_signed_cookie, 'c')
def login(request):
http_response = HttpResponse()
issave = request.POST.get('isSave')
if request.method == 'POST':
username = request.POST.get('username', None)
password = request.POST.get('password', None)
if username and password:
if len(username) > 5:
# 读取文件
# search_user(username, password)
# login_success = search_user(username, password)
# login_success = auth.authenticate(username=username, password=password)
try:
login_success = User.objects.filter(username=username,password=password)
except:
username = None
if username:
# if len(login_success) < 0:
if issave:
http_response.set_cookie('username', username, max_age=10)
http_response.set_signed_cookie('password', password, salt='111')
# http_response.set_cookie('password', password)
info = u'欢迎登录：%s' % username
else:
info = u'用户名或密码错误'
else:
info = u'用户名长度不足5位'
else:
# return HttpResponse(content=u'用户名或密码为空', status = 400)
info = u'用户名或密码为空'
else:
info = u'请求类型无效'
http_response.content = info
return http_response
def test_signed_cookies_with_binary_key(self):
response = HttpResponse()
response.set_signed_cookie('c', 'hello')
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value
self.assertEqual(request.get_signed_cookie('c'), 'hello')
def login(request):
if request.method == "POST":
username = request.POST.get('username')
password = request.POST.get('password')
userResult = user.objects.filter(username=username, password=password)
if (len(userResult) > 0):
#登陆成功
st = 1
response = HttpResponse(json.dumps({"st": st}),
content_type="application/json")
#设置cookies,加盐，后续考虑加密
response.set_signed_cookie('username',
username,
salt="cloud",
expires=3600,
max_age=3600)
return response
else:
st = 0
# 返回登陆失败页面
response = HttpResponse(json.dumps({"st": st}),
content_type="application/json")
return response
else:
st = 2
return render_to_response("login.html", {"st": st})
def test_signed_cookies_with_binary_key(self):
response = HttpResponse()
response.set_signed_cookie("c", "hello")
request = HttpRequest()
request.COOKIES["c"] = response.cookies["c"].value
self.assertEqual(request.get_signed_cookie("c"), "hello")
def star_rating_vote(request, pk):
star_rating = get_object_or_404(StarRating, pk=pk)
data = {'total': star_rating.total, 'votes': star_rating.votes}
if request.get_signed_cookie('star_rating-%d' % star_rating.id, False):
data['message'] = u'Вы уже ставили оценку.'
return HttpResponse(json.dumps(data),
content_type='application/javascript')
if request.method == 'POST' and request.POST.get('rate'):
rate = int(request.POST['rate'])
if rate in range(1, 6):
if request.user.is_authenticated():
star_rating.vote_user(rate)
else:
star_rating.vote_anonymous(rate)
data = {'total': star_rating.total,
'votes': star_rating.votes,
'message': u'Вы поставили %d. Спасибо за оценку.' % rate}
response = HttpResponse(json.dumps(data),
content_type='application/javascript')
response.set_signed_cookie('star_rating-%d' % star_rating.id,
'voted', max_age=365*24*60*60)
return response
def grant_sudo(client_or_request):
"""Sets a cookie on the test client or request that django-elevate will use"""
response = HttpResponse()
token = get_random_string()
response.set_signed_cookie(
elevate_settings.COOKIE_NAME,
token,
salt=elevate_settings.COOKIE_SALT,
max_age=elevate_settings.COOKIE_AGE,
secure=False,
httponly=True,
path=elevate_settings.COOKIE_PATH,
domain=elevate_settings.COOKIE_DOMAIN,
)
if hasattr(client_or_request, "cookies"):
client_or_request.cookies[elevate_settings.COOKIE_NAME] = response.cookies[elevate_settings.COOKIE_NAME]
elif hasattr(client_or_request, "COOKIES"):
client_or_request.COOKIES[elevate_settings.COOKIE_NAME] = response.cookies[elevate_settings.COOKIE_NAME].value
else:
raise TypeError("%r has neither cookies nor COOKIES" % client_or_request)
# client.session is a property that returns new objects
session = client_or_request.session
session[elevate_settings.COOKIE_NAME] = token
session.save()
def test_signed_cookies_with_binary_key(self):
response = HttpResponse()
response.set_signed_cookie('c', 'hello')
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value
self.assertEqual(request.get_signed_cookie('c'), 'hello')
def cookie(request):
#
# request.COOKIES
# request.COOKIES['username111']
request.COOKIES.get('username111')
response = render(request, 'index.html')
response = redirect('/index/')
# 设置cookie，关闭浏览器失效
response.set_cookie('key', "value")
# 设置cookie, N秒只有失效
response.set_cookie('username111', "value", max_age=10)
# 设置cookie, 截止时间失效
import datetime
current_date = datetime.datetime.utcnow()
current_date = current_date + datetime.timedelta(seconds=5)
response.set_cookie('username111', "value", expires=current_date)
response.set_cookie('username111', "value", max_age=10)
# request.COOKIES.get('...')
# response.set_cookie(...)
obj = HttpResponse('s')
obj.set_signed_cookie('username', "kangbazi", salt="asdfasdf")
request.get_signed_cookie('username', salt="asdfasdf")
return response
def test_signed_cookies_with_binary_key(self):
response = HttpResponse()
response.set_signed_cookie("c", "hello")
request = HttpRequest()
request.COOKIES["c"] = response.cookies["c"].value
self.assertEqual(request.get_signed_cookie("c"), "hello")
def grant_sudo(client_or_request):
"""Sets a cookie on the test client or request that django-elevate will use"""
response = HttpResponse()
token = get_random_string()
response.set_signed_cookie(
elevate_settings.COOKIE_NAME,
token,
salt=elevate_settings.COOKIE_SALT,
max_age=elevate_settings.COOKIE_AGE,
secure=False,
httponly=True,
path=elevate_settings.COOKIE_PATH,
domain=elevate_settings.COOKIE_DOMAIN,
)
if hasattr(client_or_request, "cookies"):
client_or_request.cookies[
elevate_settings.COOKIE_NAME] = response.cookies[
elevate_settings.COOKIE_NAME]
elif hasattr(client_or_request, "COOKIES"):
client_or_request.COOKIES[
elevate_settings.COOKIE_NAME] = response.cookies[
elevate_settings.COOKIE_NAME].value
else:
raise TypeError("%r has neither cookies nor COOKIES" %
client_or_request)
# client.session is a property that returns new objects
session = client_or_request.session
session[elevate_settings.COOKIE_NAME] = token
session.save()
def test_detects_tampering(self):
response = HttpResponse()
response.set_signed_cookie("c", "hello")
request = HttpRequest()
request.COOKIES["c"] = response.cookies["c"].value[:-2] + "$$"
with self.assertRaises(signing.BadSignature):
request.get_signed_cookie("c")
def cookie(request):
# 获取cookie
request.COOKIES
request.COOKIES['username111']
request.COOKIES.get('username111')
# 设置cookie
response = render(request, 'index.html')
response = redirect('/index/')
# 设置cookie，关闭浏览器就失效
response.set_cookie('key', 'value')
# 设置cookie，N秒后失效
response.set_cookie('username111', 'value', max_age=100)
# 自定义时间删除cookie
import datetime
current_data = datetime.datetime.utcnow()
current_data = current_data + datetime.timedelta(seconds=500)
# 转换成时间的截止日期传进去
response.set_cookie('username111', 'value', expires=current_data)
# cookie加密，用aaaa方式加密
obj = HttpResponse('s')
obj.set_signed_cookie('username111', 'lkk', salt="aaaa")
# cookie解密也得用aaaa解密
request.get_signed_cookie('username111', salt='aaaa')
return response
def homeTest(request):
if request.method == 'POST':
account = request.POST.get('account')
password = request.POST.get('password')
print(account, password)
request.session['token'] = 'hhh'
map = {}
map['account'] = account
map['password'] = password
result = {"status": 1, "data": map, "msg": "登录返回数据"}
response = HttpResponse(json.dumps(result, ensure_ascii=False),
content_type="application/json,charset=utf-8")
response.set_cookie('account', account)
response.set_cookie('password', password) # 不加密cookie
response.set_signed_cookie('', '', salt='encode-name') # 加密cookie
return response
else:
token = request.session.get('token', None)
account = request.COOKIES.get('account', None)
pwd = request.COOKIES['password']
# request.get_signed_cookie('', default=RAISE_ERROR, salt='', max_age=None) #获取加密的cookie
if token:
return render(request, template_name='Entry/home.html')
else:
return HttpResponseRedirect('/login')
def alipay_trade_query(request):
'''交易订单查询'''
up_order = request.get_signed_cookie('out_trade_no', None)
order = request.POST.dict()
if order['out_trade_no'] == up_order:
return HttpResponse(
json.dumps({
'code': 1,
'msg': f"成功支付 {order.get('total_amount')} 元"
}))
result = init_alipay().api_alipay_trade_query(
out_trade_no=order['out_trade_no'])
if result.get("trade_status", "") == "TRADE_SUCCESS":
res = HttpResponse(
json.dumps({
'code': 1,
'msg': f"成功支付 {result.get('total_amount')} 元"
}))
res.set_signed_cookie('out_trade_no', order['out_trade_no'])
return res
elif result.get("trade_status", "") == "TRADE_CLOSED":
return HttpResponse(
json.dumps({
'code': 0,
'msg': result.get('sub_msg')
}))
else:
return HttpResponse(
json.dumps({
'code': 2,
'msg': result.get('sub_msg')
}))
def test_detects_tampering(self):
response = HttpResponse()
response.set_signed_cookie('c', 'hello')
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value[:-2] + '$$'
with self.assertRaises(signing.BadSignature):
request.get_signed_cookie('c')
def test_detects_tampering(self):
response = HttpResponse()
response.set_signed_cookie("c", "hello")
request = HttpRequest()
request.COOKIES["c"] = response.cookies["c"].value[:-2] + "$$"
with self.assertRaises(signing.BadSignature):
request.get_signed_cookie("c")
def add_cookies(request):
response = HttpResponse("<h3>Cookie添加成功！</h3>")
response.set_cookie("fruit",
"苹果".encode("utf-8")) # 设置Cookie，在Django中中文必须编码
response.set_cookie("sport", "pingpong", max_age=30)
response.set_signed_cookie("account", "tom123", salt="abcde",
max_age=30) # 加盐Cookie
return response
def login_view(request):
# return HttpResponse('123')
if request.method == 'GET':
if request.COOKIES.has_key('login'):
login = request.get_signed_cookie('login', salt='hello').split(',')
uname = login[0]
pwd = login[1]
remember = login[2]
return render(request, 'login.html', {
'uname': uname,
'pwd': pwd,
'remember': remember
})
return render(request, 'login.html')
#获取用户数据
else:
uname = request.POST.get('uname', '')
pwd = request.POST.get('pwd', '')
remember = request.POST.get('remember', '')
# 用cookie记住用户名、密码
if remember == 'on':
remember = '1'
else:
remember = '0'
response = HttpResponse()
# 遍历用户数据库匹配
if uname and pwd:
users = User.objects.filter(user_name=uname, user_password=pwd)
if users:
#登陆成功用session记住用户
for use in users:
uid = use.user_id
# if uid < 5:
# # del request.session['uname']
# request.session['uname'] = '管理员'
# request.session.set_expiry(60 * 60 * 24 * 3)
# return render(request, 'base.html')
# else:
# del request.session['uname']
request.session['uname'] = uname
request.session.set_expiry(60 * 60 * 24 * 3)
return redirect('/login/index/')
if remember == '1':
response.set_signed_cookie('login',
uname + ',' + pwd + ',' +
remember,
salt='hello',
path='/',
max_age=72 * 60 * 60)
return response
else:
response.delete_cookie('login', path='/login/')
return response
else:
response.delete_cookie('login', path='/login/')
return render(request, 'relogin.html')
def test_can_set_and_read_signed_cookies(self):
response = HttpResponse()
response.set_signed_cookie("c", "hello")
self.assertIn("c", response.cookies)
self.assertTrue(response.cookies["c"].value.startswith("hello:"))
request = HttpRequest()
request.COOKIES["c"] = response.cookies["c"].value
value = request.get_signed_cookie("c")
self.assertEqual(value, "hello")
def test_can_use_salt(self):
response = HttpResponse()
response.set_signed_cookie("a", "hello", salt="one")
request = HttpRequest()
request.COOKIES["a"] = response.cookies["a"].value
value = request.get_signed_cookie("a", salt="one")
self.assertEqual(value, "hello")
with self.assertRaises(signing.BadSignature):
request.get_signed_cookie("a", salt="two")
def test_can_set_and_read_signed_cookies(self):
response = HttpResponse()
response.set_signed_cookie("c", "hello")
self.assertIn("c", response.cookies)
self.assertTrue(response.cookies["c"].value.startswith("hello:"))
request = HttpRequest()
request.COOKIES["c"] = response.cookies["c"].value
value = request.get_signed_cookie("c")
self.assertEqual(value, "hello")
def test_can_use_salt(self):
response = HttpResponse()
response.set_signed_cookie("a", "hello", salt="one")
request = HttpRequest()
request.COOKIES["a"] = response.cookies["a"].value
value = request.get_signed_cookie("a", salt="one")
self.assertEqual(value, "hello")
with self.assertRaises(signing.BadSignature):
request.get_signed_cookie("a", salt="two")
def set_cookies(request):
response = HttpResponse("设置cookie")
# response.set_cookie("name", 'ddd')
response.set_signed_cookie('name', 'dddd', salt='1111')
# print(request.COOKIES['name'])
# print(request.get_signed_cookie('name'))
return response
def test_signed_cookie(request):
resp = HttpResponse('测试cookie')
msg = request.get_signed_cookie('num', salt='afsfsdfs')
print(msg)
if not msg:
# resp.set_cookie('msg', 'hello', path='/sc/cookie/')
resp.set_signed_cookie('num', 1, alt='afsfsdfs')
return resp
def test_can_set_and_read_signed_cookies(self):
response = HttpResponse()
response.set_signed_cookie('c', 'hello')
self.assertIn('c', response.cookies)
self.assertTrue(response.cookies['c'].value.startswith('hello:'))
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value
value = request.get_signed_cookie('c')
self.assertEqual(value, 'hello')
def test_can_use_salt(self):
response = HttpResponse()
response.set_signed_cookie('a', 'hello', salt='one')
request = HttpRequest()
request.COOKIES['a'] = response.cookies['a'].value
value = request.get_signed_cookie('a', salt='one')
self.assertEqual(value, 'hello')
self.assertRaises(signing.BadSignature,
request.get_signed_cookie, 'a', salt='two')
def test_can_set_and_read_signed_cookies(self):
response = HttpResponse()
response.set_signed_cookie('c', 'hello')
self.assertIn('c', response.cookies)
self.assertTrue(response.cookies['c'].value.startswith('hello:'))
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value
value = request.get_signed_cookie('c')
self.assertEqual(value, 'hello')
def test_can_use_salt(self):
response = HttpResponse()
response.set_signed_cookie('a', 'hello', salt='one')
request = HttpRequest()
request.COOKIES['a'] = response.cookies['a'].value
value = request.get_signed_cookie('a', salt='one')
self.assertEqual(value, 'hello')
with self.assertRaises(signing.BadSignature):
request.get_signed_cookie('a', salt='two')
def authenticate(request):
"""
Get credentials from Google using code from client,
and then check if the user already exists in ndb.
"""
try:
oauth_flow = OAuth2WebServerFlow(
client_id=settings.GOOGLE_CLIENT['web']['client_id'],
client_secret=settings.GOOGLE_CLIENT['web']['client_secret'],
auth_uri=settings.GOOGLE_CLIENT['web']['auth_uri'],
token_uri=settings.GOOGLE_CLIENT['web']['token_uri'],
redirect_uri='postmessage',
scope='openid email',
)
credentials = json.loads(oauth_flow.step2_exchange(request.body).to_json())
except FlowExchangeError:
return HttpResponse('{"result":"failure"}', content_type='application/json')
else:
user = User.get_by_id(credentials['id_token']['sub'])
if not user:
user = User(
id = credentials['id_token']['sub'],
email = credentials['id_token']['email'],
refresh_token = credentials.get('refresh_token'))
user.put()
try:
uid = user.key.id()
session = label_api.create_session(user_id=uid, app_id=uid, device_id=uid)
session_id = session.get('session_id')
if not session_id:
raise Exception
# Must set profile before adding ingredients
response = label_api.set_profile(session_id, user.get_profile())
if response.get('result') != 'success':
raise Exception
for label in Label.query(Label.user_id == uid, Label.sub_id != '').fetch():
label_api.add_ingredient(session_id, label.sub_id)
response = HttpResponse(json.dumps({
"success": True,
"euid": crypto.encrypt(uid)
}), content_type='application/json')
response.set_signed_cookie('session_id', session_id)
return response
except:
pass
return HttpResponse('{"success": false}', content_type='application/json')
def set_CookieInfo(request):
#在Cookie中存值
respone=HttpResponse()
#默认情况下，Cookie保存在浏览器的缓存中
#当设置了有效时长后，数据会保存到硬盘中
#respone.set_cookie('uname','zhangsan',max_age=1*24*60*60,path='/test_Cookie/abc/')
a='hello'
b=base64.encodestring(a)
respone.set_signed_cookie('uname',b,salt='hello',path='/test_Cookie/abc/')
return respone
def post(self, request: HttpRequest):
company_name = request.POST.get('companyName', None)
if company_name is not None:
data = {'success': True, 'redirect_url': '/company/'}
json_response = JsonResponse(data)
http_response = HttpResponse(json_response)
http_response.set_signed_cookie('host_user', company_name)
return http_response
data = {
'error': True,
'message': "Parameter name of the company must not be empty"
}
return JsonResponse(data)
def test_max_age_argument(self):
value = 'hello'
with freeze_time(123456789):
response = HttpResponse()
response.set_signed_cookie('c', value)
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value
self.assertEqual(request.get_signed_cookie('c'), value)
with freeze_time(123456800):
self.assertEqual(request.get_signed_cookie('c', max_age=12), value)
self.assertEqual(request.get_signed_cookie('c', max_age=11), value)
self.assertRaises(signing.SignatureExpired,
request.get_signed_cookie, 'c', max_age=10)
def test_signed_cookies_with_binary_key(self):
def restore_secret_key(prev):
settings.SECRET_KEY = prev
self.addCleanup(restore_secret_key, settings.SECRET_KEY)
settings.SECRET_KEY = b'\xe7'
response = HttpResponse()
response.set_signed_cookie('c', 'hello')
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value
self.assertEqual(request.get_signed_cookie('c'), 'hello')
def post(self, request: HttpRequest):
company_name = request.POST.get('companyName', None)
if company_name is not None and Company.objects.company_exists(
company_name):
company: Company = Company.objects.get(company_name=company_name)
if company.owned_by(request.user.username):
data = {'error': False, 'redirect_url': '/company/'}
json_response = JsonResponse(data)
http_response = HttpResponse(json_response,
content_type="application/json")
http_response.set_signed_cookie('host_user', company_name)
return http_response
data = {'error': True, 'message': "The name of company is not valid"}
return JsonResponse(data)
def cookie2(request, ):
# 获取cookie信息 如果key不存在则抛出异常
# v1 = request.COOKIES['k1']
# 获取cookie信息 如果key不存在就返回None
v1 = request.COOKIES.get('k1')
if not v1:
settings.NUM += 1
response = HttpResponse("")
# name = '空空'.encode()
response.set_signed_cookie('k4', 'kongkong', salt=settings.SECRET_KEY)
v = request.get_signed_cookie('k4', salt=settings.SECRET_KEY)
return response
def login(request):
if request.method == "POST":
email = str(request.POST.get('email'))
password = str(request.POST.get('password'))
user_id = user.is_valid_login(email, password)
if user_id:
response = HttpResponse('{\"Result\":\"Success\", \"user_id\":\"' + user_id +'\"}')
response.set_signed_cookie(key="uID", value=utils.make_cookie(user_id), salt=production.uID_salt)
return response
response = HttpResponse('False')
return response
response = HttpResponse()
response.status_code = 403
return response
def test_max_age_argument(self):
value = 'hello'
with freeze_time(123456789):
response = HttpResponse()
response.set_signed_cookie('c', value)
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value
self.assertEqual(request.get_signed_cookie('c'), value)
with freeze_time(123456800):
self.assertEqual(request.get_signed_cookie('c', max_age=12), value)
self.assertEqual(request.get_signed_cookie('c', max_age=11), value)
with self.assertRaises(signing.SignatureExpired):
request.get_signed_cookie('c', max_age=10)
def setCookie(request):
response = HttpResponse()
import datetime
# 默认保存到关闭浏览器
# 默认存储在缓存中，更改存储日期后存储到本地
# response.set_cookie('uname', 'uname', max_age=24 * 60 * 60,
# expires=datetime.datetime.today() + datetime.timedelta(days=2))
# 加密
response.set_signed_cookie('uname',
'uname',
salt='dsa',
max_age=24 * 60 * 60,
path='/cookie/getcookie/')
return response
def CookieSim(req):
if(!req.COOKIES.get("Name")): #获取Cookie
rep = HttpResponse("/index")
rep.set_cookie("Name", "alex", max_age=10, '''expires,'''path="/", domain="biadu.com", secure=True)
#设置Cookie, 周期为10s(expires为ie5之前的), path为cookie生效URL, domin表示cookie生效域名, secure表示需要https
rep.set_signed_cookie("On", "value", salt="密钥") #设置签名cookie
return rep
if req.COOKIES.has_key('ON'): #判断cookie是否存在
req.COOKIES.get("Name") #获取cookie
req.get_signed_cookie("On", salt="密钥") #获取签名cookie
ia = requests.get("URL") #登录页面获取cookie
ia2 = requests.post("URL", data={}, cookies=ia.cookies.get_dirt()) #用户登录,携带上次cookie,后台对cookie的gpsd授权
gpsd = ia.cookies.get_dirt()['gpsd'] #操作
ia3 = requests.post("URL", cookies={'gpsd'=gpsd})
def post(self, request):
json_data = json.loads(request.body.decode("utf-8"))
app_id = json_data['appId']
app_secret = json_data["appSecret"]
code = json_data["code"]
username, err = get_username(app_id, app_secret, code)
if err == 0:
if User.objects.filter(username=username).count() == 0:
os.mkdir(os.path.join(BASE_DIR, "user\\" + username))
user = User(username=username)
user.save()
response = HttpResponse("Login OK")
response.set_signed_cookie("username", username, salt='salt')
return response
else:
return HttpResponse("Login Failed")
def cookie(request):
#创建响应对象
response = HttpResponse()
#将数据存储在cookie中,默认保存在浏览器缓存中关闭浏览器就消失，持久会得加上max_age,cookie保存项目哪个路径加上path,
# 失效时间加expire,domain指定哪个域名下cookie有效(None当前域名下全部有效)，加盐salt(set_cookie是不能加salt)
response.set_signed_cookie('uname',
'zhangsan',
salt='xxxsign',
max_age=24 * 60 * 60,
path='/',
expires=datetime.datetime.today() +
datetime.timedelta(days=2))
# #删除cookie
# response.delete_cookie('uname', path='/')
# response['max_age'] = -1
return response
def test_cookies(self):
Channel("test").send({"reply_channel": "test", "http_version": "1.1", "method": "GET", "path": b"/test/"})
response = HttpResponse(b"Hi there!", content_type="text/plain")
response.set_signed_cookie("foo", "1", expires=datetime.now())
# Run the handler
handler = FakeAsgiHandler(response)
reply_messages = list(handler(self.get_next_message("test", require=True)))
# Make sure we got the right number of messages
self.assertEqual(len(reply_messages), 1)
reply_message = reply_messages[0]
# Make sure the message looks correct
self.assertEqual(reply_message["content"], b"Hi there!")
self.assertEqual(reply_message["status"], 200)
self.assertEqual(reply_message.get("more_content", False), False)
self.assertEqual(reply_message["headers"][0], (b"Content-Type", b"text/plain"))
self.assertIn("foo=", reply_message["headers"][1][1].decode())
def test_max_age_argument(self):
value = 'hello'
_time = time.time
time.time = lambda: 123456789
try:
response = HttpResponse()
response.set_signed_cookie('c', value)
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value
self.assertEqual(request.get_signed_cookie('c'), value)
time.time = lambda: 123456800
self.assertEqual(request.get_signed_cookie('c', max_age=12), value)
self.assertEqual(request.get_signed_cookie('c', max_age=11), value)
self.assertRaises(signing.SignatureExpired,
request.get_signed_cookie, 'c', max_age=10)
finally:
time.time = _time
def grant_client_sudo(client):
"""Sets a cookie on the test client that django-sudo will use"""
response = HttpResponse()
token = get_random_string()
response.set_signed_cookie(
sudo_settings.COOKIE_NAME, token,
salt=sudo_settings.COOKIE_SALT,
max_age=sudo_settings.COOKIE_AGE,
secure=False,
httponly=True,
path=sudo_settings.COOKIE_PATH,
domain=sudo_settings.COOKIE_DOMAIN,
)
client.cookies[sudo_settings.COOKIE_NAME] = response.cookies[sudo_settings.COOKIE_NAME]
session = client.session
session[sudo_settings.COOKIE_NAME] = token
session.save()
def test_default_argument_supresses_exceptions(self):
response = HttpResponse()
response.set_signed_cookie('c', 'hello')
request = HttpRequest()
request.COOKIES['c'] = response.cookies['c'].value[:-2] + '$$'
self.assertEqual(request.get_signed_cookie('c', default=None), None)
def main(request):
csrf_request = {}
response_cookie_dict = {}
debug_log = []
session_id = request.session.get('_auth_user_id', -1)
if(session_id == -1):
return login_page(request)
print "in main()"
user = User.objects.get(pk=session_id)
csrf_request['username'] = str(user)
userprofile = UserProfile.objects.get(user=user)
debug_log.append('logged in!!')
dice_list = []
##determine whether we are in a mobile platform
platform = get_platform(request.get_signed_cookie('platform', 'x86'))
#if we are playing the cpu then our turn is always 1, otherwise we can find it stored in a cookie and in the db
playing_cpu = int(request.GET.get('playing_cpu', 0))
debug_log.append('playing_cpu read from GET as %s' % str(playing_cpu))
if(playing_cpu == 1):
turn = 1
else:
turn = userprofile.turn
debug_log.append('player turn is %d after turn assignment block' %turn)
print 'player turn is %d after turn assignment block' %turn
#exit game flow
if(int(request.GET.get('exit_game', -1)) == 1):
debug_log.append('Exiting game')
response = render_to_response(index_page[platform], csrf_request, context_instance=RequestContext(request))
response.set_signed_cookie('at_index', 'True')
response.set_signed_cookie('inagame', 'False')
if(not (request.get_signed_cookie('playing_cpu', default=-1) == '1' or playing_cpu == 1)):
cookie_game_id = int(request.get_signed_cookie('game_id'))
if(len(GameRequest.objects.filter(pk=cookie_game_id)) > 0):
try:
gamerequest = GameRequest.objects.get(pk=cookie_game_id)
except:
gamerequest = -1
if(gamerequest != -1):
if(gamerequest.host == user):
gamerequest.delete()
return response
#inagame is used to determine if we should redirect to index page
get_inagame = int(request.GET.get('inagame', -1))
if(( (request.get_signed_cookie('playing_cpu', default=-1) != '1' and playing_cpu != 1))):
if(len(Game.objects.filter(pk=get_request_param(request,'game_id', -1))) > 0):
in_defunct_game = False
else:
in_defunct_game = True
else:
in_defunct_game = False
if((request.get_signed_cookie('inagame', 'False') == 'False' and get_inagame != 1) or in_defunct_game):
username = User.objects.get(pk=session_id)
csrf_request = { 'username' : str(username) }
response = render_to_response(index_page[platform], csrf_request, context_instance=RequestContext(request))
response.set_signed_cookie('at_index', 'True')
return response
#the previous_game_fsm value will not be affected by posted form data
#therefore it should only equal game_fsm when there is a refresh
#if we're plying_cpu we set previous_game_fsm to NA, so it will never = game_fsm
if(playing_cpu != 1):
previous_game_fsm = request.get_signed_cookie('game_fsm', 0)
else:
previous_game_fsm = 'NA'
game_fsm = get_request_param(request,'game_fsm', 0)
if(playing_cpu != 1 and game_fsm == 0):
game_fsm = request.get_signed_cookie('game_fsm', 0)
debug_log.append('game_fsm cookie read,')
debug_log.append(' game_fsm = %s previous_game_fsm = %s' % (str(game_fsm), str(previous_game_fsm)))
print ' game_fsm = %s previous_game_fsm = %s' % (str(game_fsm), str(previous_game_fsm))
if(get_request_param(request,'submit_type', 0) == 'New Game'):
#for now, the new game button should only appear when we are playing the cpu.
#otherwise a new request should be launched
playing_cpu = 1
game_fsm = 0
if(len(Game.objects.filter(pk=get_request_param(request,'game_id', -1))) > 0):
game = get_object_or_404(Game, pk=get_request_param(request,'game_id', -1))
game.delete()
csrf_request['game_fsm'] = game_fsm
#############################
##beginning of game FSM logic
#############################
print 'game_fsm = %s' %(str(game_fsm))
debug_str = get_request_param(request, 'debug_str', 'NA')
print '%s debug_str = %s' %(user, debug_str)
##rolls should occur regardless of whether it is our turn
if(game_fsm == "has_rolled" or game_fsm == "reroll"):
debug_str = get_request_param(request, 'debug_str', 'NA')
print '%s has_rolled/reroll, submit_type != bullshit, debug_str = %s' %(user, debug_str)
if(request.get_signed_cookie('playing_cpu', default=-1) == '1' or playing_cpu == 1):
debug_log.append('in playing_cpu and (has_rolled or reroll) block')
print 'in playing_cpu and (has_rolled or reroll) block'
#generate player roll
userprofile.roll = 0
if(game_fsm == "has_rolled"):
userprofile.num_dice = NUM_DICE
for i in range(userprofile.num_dice):
roll = random.randint(1,6)
dice_list.append(roll)
userprofile.roll += roll*(10**(i))
print "roll = %d" % userprofile.roll
userprofile.save()
if(game_fsm == "has_rolled"):
game = Game(num_players=2, has_cpu=True, log = '', num_cpu_dice = NUM_DICE, turn=1, timestamp=0)
game.num_dice = game.num_players*NUM_DICE
else:
game = get_object_or_404(Game, pk=get_request_param(request,'game_id', -1))
#generate cpu roll->only on cpu game
game.cpu_roll = 0
for i in range(game.num_cpu_dice):
roll = random.randint(1,6)
game.cpu_roll += roll*(10**(i))
print "roll = %d" % game.cpu_roll
game.save()
print "game_id = %d" %game.id
csrf_request['game_id'] = game.id
csrf_request['game_fsm'] = 'has_rolled'
csrf_request['log'] = re.split('\n', game.log)
#check if game is over
if(game_fsm == "reroll" and (game.num_cpu_dice == 0 or userprofile.num_dice == 0)):
csrf_request['game_fsm'] = 'game_over'
if(game.num_cpu_dice == 0):
csrf_request['winner'] = '%s' %(string.upper(str(csrf_request['username'])))
else:
csrf_request['winner'] = 'CPU'
## multiplayer, (game_fsm == "has_rolled" or game_fsm == "reroll")
else:
#generate player roll, but not on refresh
if(game_fsm != previous_game_fsm):
debug_log.append('rerolling...')
userprofile.roll = 0
for i in range(userprofile.num_dice):
roll = random.randint(1,6)
dice_list.append(roll)
userprofile.roll += roll*(10**(i))
print "roll = %d" % userprofile.roll
userprofile.save()
else:
debug_log.append('not rerolling...')
dice_list = get_roll_from_int(userprofile.roll, userprofile.num_dice)
##must have all players join the same game
##assume this game was created by hosts request
cookie_game_id = int(request.get_signed_cookie('game_id'))
debug_log.append('game_id cookie read, game_id = %d' % cookie_game_id)
game = get_object_or_404(Game, pk=cookie_game_id)
csrf_request['game_id'] = game.id
csrf_request['game_fsm'] = 'has_rolled'
csrf_request['log'] = re.split('\n', game.log)
#determine if bullshit should be an option by parsing the last line of the logfile
#if the last line was a claim, its bullshittable. I like saying bullshittable :)
if(len(csrf_request['log']) == 1):
last_line = csrf_request['log'][0]
else:
for i in range(1,len(csrf_request['log']) +1):
last_line = csrf_request['log'][len(csrf_request['log']) - i]
if(last_line != ''):
break
debug_log.append('last_line = %s' %last_line)
if(re.search(r'claim', last_line)):
csrf_request['bullshittable'] = 1
else:
csrf_request['bullshittable'] = 0
#If there are more than 2 players then we can make a has_rolled to reroll transition when another player calls bullshit
#for instance if i am player 1, I roll, player 2 makes a claim, and player 3 calls bullshit
#of course, if the amount of players goes from 3->2, this condition fails:
#if(game.num_players > 2 and game.log != ''):
#so i am loosening it
if(game.log != ''):
get_bullshit_tuple = get_bullshit_call(game.log)
if(get_bullshit_tuple[0] == False):
csrf_request['value'] = request.get_signed_cookie('value', 0)
csrf_request['amount'] = request.get_signed_cookie('amount', 0)
debug_log.append('bullshit was not called')
print ' username = %s bullshit was not called' % str(user)
else:
#here we ensure that we only circle back to reroll once
timestamp = game.timestamp
bullshit_timestamp = int(request.get_signed_cookie('bullshit_timestamp', 0))
debug_log.append('bullshit was called, timestamp = %d bullshit_timestamp = %d' %(timestamp,bullshit_timestamp))
print ' username = %s bullshit was called, timestamp = %d bullshit_timestamp = %d' %(str(user), timestamp,bullshit_timestamp)
if(game_fsm == 'has_rolled' and (bullshit_timestamp != timestamp or bullshit_timestamp == 0)):
csrf_request['game_fsm'] = 'reroll'
response_cookie_dict['bullshit_timestamp'] = timestamp
if(game.num_players == 1):
csrf_request['game_fsm'] = 'game_over'
csrf_request['winner'] = '%s' %(get_winner(game))
debug_log.append('line = %s' %get_bullshit_tuple[1])
#check if game is over
if(userprofile.num_dice == 0):
if(game.num_players == 1):
csrf_request['game_fsm'] = 'game_over'
csrf_request['winner'] = '%s' %(get_winner(game))
else:
csrf_request['game_fsm'] = 'eliminated'
elif((game_fsm == 'has_claimed' or game_fsm == 'reclaim') and get_request_param(request,'submit_type', 0) != 'bullshit!!'):
debug_str = get_request_param(request, 'debug_str', 'NA')
print '%s reclaim/has_claimed, submit_type != bullshit, debug_str = %s' %(user, debug_str)
dice_list = get_roll_from_int(userprofile.roll, userprofile.num_dice)
##the following block of code is only executed on cpu games
if(request.get_signed_cookie('playing_cpu', default=-1) == '1'):
csrf_request['value'] = get_request_param(request,'value', 0)
csrf_request['amount'] = get_request_param(request,'amount', 0)
print 'GET game_id val = %s debug_str = %s' % (request.GET.get('game_id', 'NA'), get_request_param(request, 'debug_str', 'NA'))
game = get_object_or_404(Game, pk=get_request_param(request,'game_id', -1))
csrf_request['game_id'] = game.id
cpu_roll = get_roll_from_int(game.cpu_roll, game.num_cpu_dice)
if(game.num_dice < game.num_cpu_dice):
return HttpResponse("Illegal values, num_dice = %d < cpu_dice = %d. cpu_roll = %s" % (game.num_dice, game.num_cpu_dice, str(cpu_roll)))
liars_dice_request = {
'num_dice' : game.num_dice,
'cpu_dice' : game.num_cpu_dice,
'roll' : cpu_roll, #this is the cpus roll, not mine
'claim_value': int(get_request_param(request,'value', 0)),
'claim_amount' : int(get_request_param(request,'amount', 0)),
'first_turn' : 'no'#cpu is never first turn for now
}
game.log += 'Player claim amount: %d, player claim value: %d\n' %(liars_dice_request['claim_amount'], liars_dice_request['claim_value'])
print liars_dice_request
cpu_response = LiarsDice.LiarsDice(webmode=True, request=liars_dice_request)
if(cpu_response.BullShit):
print "Cpu says bullshit!!"
csrf_request['cpu_response'] = "Cpu says bullshit!!"
csrf_request['game_fsm'] = 'reroll'
game.log += csrf_request['cpu_response']
int_claim_value = int(csrf_request['value'])
int_claim_amount = int(csrf_request['amount'])
int_actual_amount = dice_list.count(int_claim_value) + dice_list.count(1) + cpu_roll.count(int_claim_value) + cpu_roll.count(1)
if(int_actual_amount >= int_claim_amount):
game.log += ' CPU is wrong!! actual amount of '+str(int_claim_value)+'\'s is '+str(int_actual_amount)+'\n'
game.num_cpu_dice -= 1
game.num_dice -= 1
if(game.num_cpu_dice == 0):
csrf_request['game_fsm'] = 'game_over'
csrf_request['winner'] = '%s' %(string.upper(str(csrf_request['username'])))
else:
game.log += ' CPU is right!! actual amount of '+str(int_claim_value)+'\'s is '+str(int_actual_amount)+'\n'
game.num_dice -= 1
userprofile.num_dice -= 1
if(userprofile.num_dice == 0):
csrf_request['game_fsm'] = 'game_over'
csrf_request['winner'] = 'CPU'
else:
print "Cpu claims %d %d's" % (cpu_response.cpu_claim_amount, cpu_response.cpu_claim_value)
csrf_request['cpu_response'] = "Cpu claims %d %d's\n" % (cpu_response.cpu_claim_amount, cpu_response.cpu_claim_value)
csrf_request['cpu_claim_amount'] = int(cpu_response.cpu_claim_amount)
csrf_request['cpu_claim_value'] = int(cpu_response.cpu_claim_value)
game.log += csrf_request['cpu_response']
#multiplayer game, ((game_fsm == 'has_claimed' or game_fsm == 'reclaim') and get_request_param(request,'submit_type', 0) != 'bullshit!!')
else:
debug_str = get_request_param(request, 'debug_str', 'NA')
print 'user = %s multiplayer, has_claimed or reclaim, submit_type != bullshit, debug_str = %s' %(str(user), debug_str)
game = get_object_or_404(Game, pk=request.get_signed_cookie('game_id'))
csrf_request['game_id'] = game.id
if(game_fsm != previous_game_fsm):
print 'game_fsm = %s previous_game_fsm = %s, debug_str = %s' %(str(game_fsm), str(previous_game_fsm), debug_str)
csrf_request['value'] = get_request_param(request,'value', 0)
csrf_request['amount'] = get_request_param(request,'amount', 0)
game = get_object_or_404(Game, pk=get_request_param(request,'game_id', -1))
csrf_request['game_id'] = game.id
game.log += '%s claims %d %d\'s\n' %(csrf_request['username'], int(csrf_request['amount']), int(csrf_request['value']))
game.timestamp += 1
else:
print 'game_fsm = previous_game_fsm, so this is a bullshit_refresh'
#this block determines whether bullshit was called
get_bullshit_tuple = get_bullshit_call(game.log)
if(get_bullshit_tuple[0] == False):
csrf_request['value'] = request.get_signed_cookie('value', 0)
csrf_request['amount'] = request.get_signed_cookie('amount', 0)
debug_log.append('bullshit was not called')
print 'bullshit was not called'
else:
csrf_request['game_fsm'] = 'reroll'
debug_log.append('bullshit was called')
print 'bullshit was called'
timestamp = game.timestamp
response_cookie_dict['bullshit_timestamp'] = timestamp
#check if game is over
if(userprofile.num_dice == 0):
if(game.num_players == 1):
csrf_request['game_fsm'] = 'game_over'
csrf_request['winner'] = '%s' %(get_winner(game))
else:
csrf_request['game_fsm'] = 'eliminated'
elif(game.num_players == 1):
csrf_request['game_fsm'] = 'game_over'
##this could be more efficient. if user has > 0 dice and 1 player remains, he/she is the winner
csrf_request['winner'] = '%s' %(get_winner(game))
debug_log.append('line = %s' %get_bullshit_tuple[1])
csrf_request['log'] = re.split('\n', game.log)
game.save()
elif((game_fsm == 'reclaim' or game_fsm == 'has_claimed') and get_request_param(request,'submit_type', 0) == 'bullshit!!'):
debug_str = get_request_param(request, 'debug_str', 'NA')
print '%s reclaim/has_claimed, submit_type = bullshit, debug_str = %s' %(user, debug_str)
##following evaluates bullshit claim when playing cpu
dice_list = get_roll_from_int(userprofile.roll, userprofile.num_dice)
if(request.get_signed_cookie('playing_cpu', default=-1) == '1'):
int_claim_value = int(get_request_param(request,'cpu_claim_value', 0))
int_claim_amount = int(get_request_param(request,'cpu_claim_amount', 0))
game = get_object_or_404(Game, pk=get_request_param(request,'game_id', -1))
csrf_request['game_id'] = game.id
game.log += '%s calls bullshit!! ' %(user)
cpu_roll = get_roll_from_int(game.cpu_roll, game.num_cpu_dice)
if(dice_list.count(int_claim_value) + dice_list.count(1) + cpu_roll.count(int_claim_value) + cpu_roll.count(1) >= int_claim_amount):
print 'subtracting num_dice'
game.log += 'he/she is Wrong!!\n'
game.num_dice -= 1
userprofile.num_dice -= 1
if(userprofile.num_dice == 0):
csrf_request['game_fsm'] = 'game_over'
csrf_request['winner'] = 'CPU'
else:
print 'subtracting num_dice'
game.log += 'he/she is Correct!!\n'
game.num_dice -= 1
game.num_cpu_dice -= 1
if(game.num_cpu_dice == 0):
csrf_request['game_fsm'] = 'game_over'
csrf_request['winner'] = '%s' %(string.upper(str(user)))
#multiplayer, ((game_fsm == 'reclaim' or game_fsm == 'has_claimed') and get_request_param(request,'submit_type', 0) == 'bullshit!!')
else:
game = get_object_or_404(Game, pk=request.get_signed_cookie('game_id'))
log_array = re.split(r'\n', game.log)
log_array.reverse()
for line in log_array:
line_re = re.search(r'claims\s+(\d+)\s+(\d+)\'s', line)
if(line_re != None):
int_claim_amount = int(line_re.groups(0)[0])
int_claim_value = int(line_re.groups(0)[1])
break
debug_log.append('bullshit called on claim_amount %d claim_value %d' %(int_claim_amount, int_claim_value))
csrf_request['game_id'] = game.id
game.log += '%s calls bullshit!!' %(user)
game.timestamp += 1
##evaluate bullshit when playing other players
count = 0
for player in game.players.all():
player_profile = UserProfile.objects.get(user=player)
player_roll = get_roll_from_int(player_profile.roll, player_profile.num_dice)
count += (player_roll.count(int_claim_value) + player_roll.count(1))
if(count>= int_claim_amount):
game.log += ' he/she is Wrong!!'
print 'subtracting num_dice'
game.num_dice -= 1
userprofile.num_dice -= 1
userprofile.save()
losers_turn = userprofile.turn
#winner must go first next round
game.turn = (userprofile.turn - 1)%game.num_players
if(game.turn == 0):
game.turn = game.num_players
#if previous player out of game, we must shift turns of all players
if(userprofile.num_dice == 0):
game.log += ' %s eliminated!!\n' % (csrf_request['username'])
csrf_request['game_fsm'] = 'eliminated'
shift_players = True
else:
game.log += '\n'
shift_players = False
else:
##following evaluates bullshit claim when playing multiplayer
game.log += ' he/she is Correct!!'
game.num_dice -= 1
print 'subtracting num_dice'
#winner must go first next round
game.turn = userprofile.turn
for player in game.players.all():
player_profile = UserProfile.objects.get(user=player)
##special case: user is turn 1. requires special handling because previous player actually has turn = game.num_players
##solution: create tmp 'turn' variable. set to 0 if player_profile.turn = game.num_players
tmp_player_profile_turn = player_profile.turn
if(tmp_player_profile_turn == game.num_players):
tmp_player_profile_turn = 0
if(tmp_player_profile_turn == (userprofile.turn-1)%game.num_players and player_profile.num_dice > 0):
previous_player = UserProfile.objects.get(user=player)
previous_player.num_dice -= 1
previous_player.save()
losers_turn = previous_player.turn
#if previous player out of game, we must shift turns of all players
if(previous_player.num_dice == 0):
game.log += '%s eliminated!!\n' % (player)
debug_log.append( '%s eliminated!!\n' % (player))
shift_players = True
else:
game.log += '\n'
shift_players = False
break
#if previous player out of game, we must shift turns of all players
debug_log.append('shift_players = %s' % str(shift_players))
debug_log.append('before shift %s has turn %d' %(user, userprofile.turn))
if(shift_players):
game.num_players -= 1
debug_log.append('game.num_players = %d' % (game.num_players))
for player in game.players.all():
player_profile = UserProfile.objects.get(user=player)
if(player_profile.turn >= losers_turn and player_profile != userprofile):
debug_log.append('shifting turn of player %s' % (player))
up = UserProfile.objects.get(user=player)
up.turn-=1
up.save()
if(userprofile.turn >= losers_turn):
#current user must be handled differently. efficiency: can the save be removed?
userprofile.turn -= 1
userprofile.save()
debug_log.append('after shift %s has turn %d' %(user, userprofile.turn))
#if 1 player left, must declare winner
if(game.num_players == 1):
csrf_request['game_fsm'] = 'game_over'
if(userprofile.num_dice != 0):
csrf_request['winner'] = '%s' % (string.upper(str(csrf_request['username'])))
else:
csrf_request['winner'] = get_winner(game)
####end of 'end of game' code
timestamp = game.timestamp
response_cookie_dict['bullshit_timestamp'] = timestamp
if(csrf_request['game_fsm'] != 'game_over' and csrf_request['game_fsm'] != 'eliminated'):
csrf_request['game_fsm'] = 'reroll'
csrf_request['log'] = re.split('\n', game.log)
game.save()
if(game_fsm == 'eliminated'):
debug_log.append('You have been eliminated')
game = get_object_or_404(Game, pk=request.get_signed_cookie('game_id'))
if(game.num_players == 1):
csrf_request['game_fsm'] = 'game_over'
csrf_request['winner'] = get_winner(game)
csrf_request['dice_list'] = dice_list
userprofile.save()
##I don't want to set turn when game_fsm=0, at this point we are rolling, and its really noones turn yet
##I also don't want to save game, since it hasn't begun
if(request.get_signed_cookie('playing_cpu', default=-1) == '1' or playing_cpu == 1):
csrf_request['playing_cpu'] = 1
csrf_request['my_turn'] = 1
if(game_fsm == 0 and get_request_param(request,'multiplayer_begin', False)):
csrf_request['game_id'] = game.id
else:
csrf_request['playing_cpu'] = 0
if(game_fsm != 0 and game_fsm != 'game_over'):
#the following occurs when last player calls bullshit, is shifted down
if(game.turn > game.num_players):
game.turn = game.num_players
if(game.turn == userprofile.turn and userprofile.num_dice > 0):
csrf_request['my_turn'] = 1
#turns only increment on claims
if(game_fsm != previous_game_fsm and game_fsm != 'has_rolled' and game_fsm != 'reroll' and get_request_param(request,'submit_type', 0) != 'bullshit!!'):
#if you've claimed, its no longer your turn. Increment game counter
csrf_request['my_turn'] = 0
#modulo addtion, but count from 1 to num_playes
game.turn = (game.turn + 1) % game.num_players
if(game.turn == 0):
game.turn = game.num_players
else:
csrf_request['my_turn'] = 0
#if game length > 2300 we must remove some lines, adjust bullshit timestamp accordingly
if(len(game.log) > 2300):
game.log = game.log[500:len(game.log)]
game.save()
elif( get_request_param(request,'multiplayer_begin', False)):
csrf_request['game_id'] = game.id
####
if(request.get_signed_cookie('playing_cpu', default=-1) != '1' and playing_cpu != 1):
debug_log.append('player turn = %d game turn = %d my_turn = %d' %(userprofile.turn, game.turn, csrf_request['my_turn']))
print 'player = %s turn = %d game turn = %d my_turn = %d' %(csrf_request['username'], userprofile.turn, game.turn, csrf_request['my_turn'])
debug_log.append('in response, csrf_request game_fsm = %s' %csrf_request['game_fsm'])
csrf_request['debug_log'] = debug_log
#only print last line(for now, may change later)
if(len(csrf_request.get('log', [])) >= 2):
csrf_request['log'] = csrf_request['log'][-2:-1]
if(debug == False):
csrf_request['debug_log'] = []
#helps determine if page load is the result of an ajax autosubmission
csrf_request['autosubmission'] = get_request_param(request,'autosubmission', 0)
if(request.get_signed_cookie('playing_cpu', default=-1) != '1' and playing_cpu != 1):
csrf_request['timestamp'] = game.timestamp
csrf_request.update(csrf(request))
if(get_request_param(request,'ajax_submission', 0) == 0):
response = render_to_response(main_page[platform], csrf_request, context_instance=RequestContext(request))
print 'main returning a normal rendeer_to_response'
else:
print 'main returning a json response'
json_request_dict = {}
json_request_dict['my_turn'] = csrf_request.get('my_turn', 0)
json_request_dict['game_fsm'] = csrf_request.get('game_fsm', 0)
json_request_dict['dice_list'] = csrf_request.get('dice_list', 0)
json_request_dict['log'] = csrf_request.get('log', '')
json_request_dict['game_id'] = csrf_request.get('game_id', -1)
json_request_dict['bullshittable'] = csrf_request.get('bullshittable', 0)
json_request_dict['winner'] = csrf_request.get('winner', 'NA')
json_request_dict['username'] = csrf_request.get('username', '')
if(request.get_signed_cookie('playing_cpu', default=-1) == '1' or playing_cpu == 1):
json_request_dict['last_claim_amount'] = csrf_request.get('cpu_claim_amount', 0)
json_request_dict['last_claim_value'] = csrf_request.get('cpu_claim_value', 0)
print 'populated json dict'
json_str = simplejson.dumps(json_request_dict)
print "main() json_str:"
print json_str
response = HttpResponse(json_str, mimetype='application/json')
print 'response assigned'
#save state in a cookie, necessarry for autorefresh
response.set_signed_cookie('game_fsm', csrf_request['game_fsm'])
response.set_signed_cookie('previous_game_fsm', previous_game_fsm)
if(csrf_request.get('claim_value', -1) != -1):
response.set_signed_cookie('claim_value', csrf_request['claim_value'])
if(csrf_request.get('claim_amount', -1) != -1):
response.set_signed_cookie('claim_amount', csrf_request['claim_amount'])
if(get_inagame == 1):
response.set_signed_cookie('inagame', 1)
if(playing_cpu == 1):
response.set_signed_cookie('playing_cpu', 1)
for key,val in response_cookie_dict.iteritems():
response.set_signed_cookie(key,val)
print 'returning response!!'
return response
def test_default_argument_suppresses_exceptions(self):
response = HttpResponse()
response.set_signed_cookie("c", "hello")
request = HttpRequest()
request.COOKIES["c"] = response.cookies["c"].value[:-2] + "$$"
self.assertEqual(request.get_signed_cookie("c", default=None), None)
