def create_channel_params(self, url_match, channel_item, wsgi_environ,
raw_request):
""" Collects parameters specific to this channel (HTTP) and updates wsgi_environ
with HTTP-specific data.
"""
path_params = url_match.named
qs = wsgi_environ.get('QUERY_STRING')
qs = QueryDict(qs, encoding='utf-8')
if channel_item.data_format == DATA_FORMAT.POST:
post = QueryDict(raw_request, encoding='utf-8')
else:
post = QueryDict(None, encoding='utf-8')
wsgi_environ['zato.http.GET'] = qs
wsgi_environ['zato.http.POST'] = post
if channel_item.url_params_pri == URL_PARAMS_PRIORITY.QS_OVER_PATH:
path_params.update((key, value) for key, value in qs.items())
channel_params = path_params
else:
channel_params = dict((key, value) for key, value in qs.items())
channel_params.update(path_params)
return channel_params
def create_channel_params(self, url_match, channel_item, wsgi_environ, raw_request):
""" Collects parameters specific to this channel (HTTP) and updates wsgi_environ
with HTTP-specific data.
"""
path_params = url_match.named
qs = wsgi_environ.get('QUERY_STRING')
qs = QueryDict(qs, encoding='utf-8')
if channel_item.data_format == DATA_FORMAT.POST:
post = QueryDict(raw_request, encoding='utf-8')
else:
post = QueryDict(None, encoding='utf-8')
wsgi_environ['zato.http.GET'] = qs
wsgi_environ['zato.http.POST'] = post
if channel_item.url_params_pri == URL_PARAMS_PRIORITY.QS_OVER_PATH:
path_params.update((key, value) for key, value in qs.items())
channel_params = path_params
else:
channel_params = dict((key, value) for key, value in qs.items())
channel_params.update(path_params)
return channel_params
def test_immutable_basic_operations(self):
q = QueryDict('')
self.assertEqual(q.getlist('foo'), [])
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(q.items(), [])
self.assertEqual(q.lists(), [])
self.assertEqual(q.items(), [])
self.assertEqual(q.keys(), [])
self.assertEqual(q.values(), [])
self.assertEqual(len(q), 0)
self.assertEqual(q.urlencode(), '')
def test_non_default_encoding(self):
"""#13572 - QueryDict with a non-default encoding"""
q = QueryDict('sbb=one', encoding='rot_13')
self.assertEqual(q.encoding , 'rot_13' )
self.assertEqual(q.items() , [(u'foo', u'bar')] )
self.assertEqual(q.urlencode() , 'sbb=one' )
q = q.copy()
self.assertEqual(q.encoding , 'rot_13' )
self.assertEqual(q.items() , [(u'foo', u'bar')] )
self.assertEqual(q.urlencode() , 'sbb=one' )
self.assertEqual(copy.copy(q).encoding , 'rot_13' )
self.assertEqual(copy.deepcopy(q).encoding , 'rot_13')
def test_non_default_encoding(self):
"""#13572 - QueryDict with a non-default encoding"""
q = QueryDict("sbb=one", encoding="rot_13")
self.assertEqual(q.encoding, "rot_13")
self.assertEqual(q.items(), [(u"foo", u"bar")])
self.assertEqual(q.urlencode(), "sbb=one")
q = q.copy()
self.assertEqual(q.encoding, "rot_13")
self.assertEqual(q.items(), [(u"foo", u"bar")])
self.assertEqual(q.urlencode(), "sbb=one")
self.assertEqual(copy.copy(q).encoding, "rot_13")
self.assertEqual(copy.deepcopy(q).encoding, "rot_13")
def test_non_default_encoding(self):
"""#13572 - QueryDict with a non-default encoding"""
q = QueryDict('sbb=one', encoding='rot_13')
self.assertEqual(q.encoding , 'rot_13' )
self.assertEqual(q.items() , [(u'foo', u'bar')] )
self.assertEqual(q.urlencode() , 'sbb=one' )
q = q.copy()
self.assertEqual(q.encoding , 'rot_13' )
self.assertEqual(q.items() , [(u'foo', u'bar')] )
self.assertEqual(q.urlencode() , 'sbb=one' )
self.assertEqual(copy.copy(q).encoding , 'rot_13' )
self.assertEqual(copy.deepcopy(q).encoding , 'rot_13')
def test_immutable_basic_operations(self):
q = QueryDict('')
self.assertEqual(q.getlist('foo'), [])
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(q.items(), [])
self.assertEqual(q.lists(), [])
self.assertEqual(q.items(), [])
self.assertEqual(q.keys(), [])
self.assertEqual(q.values(), [])
self.assertEqual(len(q), 0)
self.assertEqual(q.urlencode(), '')
def test_non_default_encoding(self):
"""#13572 - QueryDict with a non-default encoding"""
q = QueryDict('cur=%A4', encoding='iso-8859-15')
self.assertEqual(q.encoding, 'iso-8859-15')
self.assertEqual(list(q.items()), [('cur', '€')])
self.assertEqual(q.urlencode(), 'cur=%A4')
q = q.copy()
self.assertEqual(q.encoding, 'iso-8859-15')
self.assertEqual(list(q.items()), [('cur', '€')])
self.assertEqual(q.urlencode(), 'cur=%A4')
self.assertEqual(copy.copy(q).encoding, 'iso-8859-15')
self.assertEqual(copy.deepcopy(q).encoding, 'iso-8859-15')
def test_non_default_encoding(self):
"""#13572 - QueryDict with a non-default encoding"""
q = QueryDict("cur=%A4", encoding="iso-8859-15")
self.assertEqual(q.encoding, "iso-8859-15")
self.assertEqual(list(q.items()), [("cur", "€")])
self.assertEqual(q.urlencode(), "cur=%A4")
q = q.copy()
self.assertEqual(q.encoding, "iso-8859-15")
self.assertEqual(list(q.items()), [("cur", "€")])
self.assertEqual(q.urlencode(), "cur=%A4")
self.assertEqual(copy.copy(q).encoding, "iso-8859-15")
self.assertEqual(copy.deepcopy(q).encoding, "iso-8859-15")
def test_non_default_encoding(self):
"""#13572 - QueryDict with a non-default encoding"""
q = QueryDict('cur=%A4', encoding='iso-8859-15')
self.assertEqual(q.encoding, 'iso-8859-15')
self.assertEqual(list(q.items()), [('cur', '€')])
self.assertEqual(q.urlencode(), 'cur=%A4')
q = q.copy()
self.assertEqual(q.encoding, 'iso-8859-15')
self.assertEqual(list(q.items()), [('cur', '€')])
self.assertEqual(q.urlencode(), 'cur=%A4')
self.assertEqual(copy.copy(q).encoding, 'iso-8859-15')
self.assertEqual(copy.deepcopy(q).encoding, 'iso-8859-15')
def verify_auth_token(data):
"""
Verifies a Auth Token in a QueryDict. Returns a
django.contrib.auth.models.User instance if successful or False.
"""
if 'auth_token' not in data:
logger.error('There is no "auth_token" in response')
return False
if 'request_token' not in data:
logger.error('There is no "request_token" in response')
return False
auth_token = data['auth_token']
params = [('auth_token', auth_token), ('key', settings.SSO_KEY)]
url = urljoin(SSO_SERVER, 'sso/verify') + '/'
response = send_sso_request(url, params)
if response.status_code != 200:
return False
data = QueryDict(response.content)
if 'signature' not in data:
logger.error('There is no "signature" in response')
return False
if 'user' not in data:
logger.error('There is no "user" in response')
return False
params = [(key, value) for key, value in data.items() if key != 'signature']
if not verify_signature(params, data['signature'], settings.SSO_SECRET):
logger.info('Cannot verify signature %s', settings.SSO_SECRET)
return False
return json.loads(data['user'])
def document(request, doctype, docid):
"""
Proxies requests for specific documents to Superfastmatch.
Does not implement the DELETE method so as to avoid access
control issues.
"""
sfm = from_django_conf()
if request.method == 'POST' or request.method == 'PUT':
params = QueryDict(request.raw_post_data) if request.method == 'PUT' else request.POST
defer = (request.method == 'PUT')
text = params['text']
params = dict([(k, v)
for (k, v) in params.items()
if k not in ['put', 'text']])
response = sfm.add(doctype, docid, text=text, defer=defer, **params)
http_status = 202
elif request.method == 'GET':
response = sfm.document(doctype, docid)
http_status = 200
else:
return HttpResponseBadRequest('Only the GET and POST methods are supported.')
if isinstance(response, str):
return HttpResponse(response, content_type='text/html')
else:
return HttpResponse(json.dumps(response),
status=http_status,
content_type='application/json')
def check_configs(self, request):
params = QueryDict(request.META['QUERY_STRING'], mutable=True)
url = 'http://possible_orders.srv.w55.ru/'
possible_configs = requests.get(url).json()['specs']
for k, v in params.items():
params['cpu'] = int(params['cpu'])
params['ram'] = int(params['ram'])
params['hdd_capacity'] = int(params['hdd_capacity'])
for config in possible_configs:
if (params['cpu'] in config['cpu']) & (
params['ram'] in config['ram']
) & (params['hdd_type']
in config['hdd_type']) & (params['os'] in config['os']):
min = config['hdd_capacity'][params['hdd_type']]['from']
max = config['hdd_capacity'][params['hdd_type']]['to']
if min <= int(params['hdd_capacity']) <= max:
self.configuration_availability = True
if self.configuration_availability:
new_virtual_machine = VirtualMachine(
cpu=params['cpu'],
ram=params['ram'],
hdd_type=params['hdd_type'],
hdd_capacity=params['hdd_capacity'],
current_user=request.user)
new_virtual_machine.save()
print("!!!!!!!!!!!!!!!!")
print(new_virtual_machine.id)
pass
pass
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict('vote=yes&vote=no')
self.assertEqual(q['vote'], u'no')
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
self.assertEqual(q.get('vote', 'default'), u'no')
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.getlist('vote'), [u'yes', u'no'])
self.assertEqual(q.getlist('foo'), [])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
self.assertEqual(q.has_key('vote'), True)
self.assertEqual('vote' in q, True)
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(q.items(), [(u'vote', u'no')])
self.assertEqual(q.lists(), [(u'vote', [u'yes', u'no'])])
self.assertEqual(q.keys(), [u'vote'])
self.assertEqual(q.values(), [u'no'])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
self.assertRaises(AttributeError, q.pop, 'foo')
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
self.assertRaises(AttributeError, q.__delitem__, 'vote')
def project(request, pid):
'''
根据id获取项目
:param request:
:param pid:
:return:
'''
project = Project.objects.get(pk=pid)
if request.method == 'GET':
data = {'code': 200, 'msg': '查询成功', 'data': project.to_dict()}
return JsonResponse(data)
if request.method == 'DELETE':
project.delete()
data = {'code': 200, 'msg': '删除成功', 'data': None}
return JsonResponse(data)
if request.method == 'PUT':
put = QueryDict(request.body)
put_str = list(put.items())[0][0] # 将获取的QueryDict对象转换为str 类型
put_dict = eval(put_str) # 将str类型转换为字典类型
project.name = put_dict.get('name')
project.host = put_dict.get('host')
project.desc = put_dict.get('desc')
project.save()
data = {'code': 200, 'msg': '更新成功', 'data': project.to_dict()}
return JsonResponse(data)
def document(request, doctype, docid):
"""
Proxies requests for specific documents to Superfastmatch.
Does not implement the DELETE method so as to avoid access
control issues.
"""
sfm = from_django_conf()
if request.method == 'POST' or request.method == 'PUT':
params = QueryDict(
request.raw_post_data) if request.method == 'PUT' else request.POST
defer = (request.method == 'PUT')
text = params['text']
params = dict([(k, v) for (k, v) in params.items()
if k not in ['put', 'text']])
response = sfm.add(doctype, docid, text=text, defer=defer, **params)
http_status = 202
elif request.method == 'GET':
response = sfm.document(doctype, docid)
http_status = 200
else:
return HttpResponseBadRequest(
'Only the GET and POST methods are supported.')
if isinstance(response, str):
return HttpResponse(response, content_type='text/html')
else:
return HttpResponse(json.dumps(response),
status=http_status,
content_type='application/json')
def verify_auth_token(data):
"""
Verifies a Auth Token in a QueryDict. Returns a
django.contrib.auth.models.User instance if successful or False.
"""
if 'auth_token' not in data:
return False
if 'request_token' not in data:
return False
auth_token = data['auth_token']
params = [('auth_token', auth_token), ('key', settings.SIMPLE_SSO_KEY)]
signature = build_signature(params, settings.SIMPLE_SSO_SECRET)
params.append(('signature', signature))
url = urljoin(settings.SIMPLE_SSO_SERVER, 'verify') + '/'
response = requests.get(url, params=dict(params))
if response.status_code != 200:
return False
data = QueryDict(response.content)
if 'signature' not in data:
return False
if 'user' not in data:
return False
params = [(key, value) for key, value in data.items()
if key != 'signature']
if not verify_signature(params, data['signature'],
settings.SIMPLE_SSO_SECRET):
return False
return load_json_user(data['user'])
def put(self, request):
PUT = QueryDict(request.body)
comment_id = PUT.get('id')
if id is None:
return JsonResponse({'message': 'Failed'})
comment_id = int(comment_id)
try:
comment_data = Comment.objects.filter(id=comment_id)
except Exception as e:
print(e)
return JsonResponse({'message': 'Failed'})
param = {}
for key, value in PUT.items():
if key == 'id' or key == 'parent_comment_id':
continue
param[key] = value
param['edit_time'] = datetime.datetime.strftime(
datetime.datetime.now(), "%Y-%m-%d %H:%M:%S")
try:
comment_data.update(**param)
except Exception as e:
print(e)
return JsonResponse({'message': 'Failed'})
return JsonResponse({'message': 'OK'})
def query(request, **kwargs):
entries = Entry.objects.accessibles(request.user)
queries = QueryDict('').copy()
queries.update(kwargs)
queries.update(request.GET)
for k, v in queries.items():
if k in ('cate', 'cat', 'c', 'category'):
entries = entries.filter(category=int(v))
if k in ('tag', 't'):
entries = entries.filter(tags=int(v))
if k in ('year', 'y'):
entries = entries.filter(created__year=v)
if k in ('month', 'm'):
entries = entries.filter(created__month=v)
if k in ('day', 'd'):
entries = entries.filter(created__day=v)
if k in ('ym', 'ymd'):
parts = re.split('[-\.\/]', v)
year, month, day = parts[0], parts[
1], len(parts) is 3 and parts[2] or None
entries = entries.filter(created__year=year, created__month=month)
if day:
entries = entries.filter(created__day=day)
if k == 'search':
q = Q(pk=-1) # empty queryset
for f in search_fields:
q |= Q(**{'%s__contains' % f: v})
entries = entries.filter(q)
try:
page = int(queries.get('page', 1))
if page == 0: page = 1
except ValueError:
page = 1
paginator = Paginator(entries, ezsettings.get('blog.articles_per_page',
10))
try:
entries = paginator.page(page)
except (EmptyPage, PageNotAnInteger):
entries = paginator.page(paginator.num_pages)
context = {
'entry_list': entries,
'paginator': paginator,
'current_page': entries.number,
'current_url': request.get_full_path(), # 当前页面URL
}
return render_to_response('blog/list.html',
context,
context_instance=RequestContext(
request, processors=[_base_context]))
def _qrem(qdict, qrem):
qrem_dict = QueryDict(qrem)
for key, val in qrem_dict.items():
oldlist = qdict.getlist(key)
oldlist.remove(val)
qdict.setlist(key, oldlist)
return qdict
def test_single_key_value(self):
"""Test QueryDict with one key/value pair"""
q = QueryDict('foo=bar')
self.assertEqual(q['foo'], 'bar')
self.assertRaises(KeyError, q.__getitem__, 'bar')
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
self.assertEqual(q.get('foo', 'default'), 'bar')
self.assertEqual(q.get('bar', 'default'), 'default')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertEqual(q.getlist('bar'), [])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar'])
self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
self.assertTrue(q.has_key('foo'))
self.assertTrue('foo' in q)
self.assertFalse(q.has_key('bar'))
self.assertFalse('bar' in q)
self.assertEqual(q.items(), [(u'foo', u'bar')])
self.assertEqual(q.lists(), [(u'foo', [u'bar'])])
self.assertEqual(q.keys(), ['foo'])
self.assertEqual(q.values(), ['bar'])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
self.assertRaises(AttributeError, q.pop, 'foo')
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
self.assertEqual(q.urlencode(), 'foo=bar')
def put(self, request):
PUT = QueryDict(request.body)
username = PUT.get('username')
if username is None or username != request.session.get('username'):
return JsonResponse({'message': 'Failed'})
try:
user_data = User.objects.filter(username=username)
except Exception as e:
print(e)
return JsonResponse({'message': 'Failed'})
param = {}
for key, value in PUT.items():
if key == 'password' or key == 'username':
continue
param[key] = value
try:
user_data.update(**param)
except Exception as e:
print(e)
return JsonResponse({'message': 'Failed'})
return JsonResponse({'message': 'OK'})
def get_request_token():
"""
Requests a Request Token from the SSO Server. Returns False if the request
failed.
"""
params = [('key', settings.SSO_KEY)]
url = urljoin(SSO_SERVER, 'sso/request-token') + '/'
response = send_sso_request(url, params)
if response.status_code != 200:
logger.error('Bad status code: %s', response.status_code)
return False
data = QueryDict(response.content)
if 'signature' not in data:
logger.error('There is no "signature" in response')
return False
if 'request_token' not in data:
logger.error('There is no "request_token" in response')
return False
params = [(key, value) for key, value in data.items() if key != 'signature']
if not verify_signature(params, data['signature'], settings.SSO_SECRET):
logger.info('Bad signature %s; params %s', data['signature'], str(params))
return False
return data['request_token']
def test_single_key_value(self):
"""Test QueryDict with one key/value pair"""
q = QueryDict('foo=bar')
self.assertEqual(q['foo'], 'bar')
self.assertRaises(KeyError, q.__getitem__, 'bar')
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
self.assertEqual(q.get('foo', 'default'), 'bar')
self.assertEqual(q.get('bar', 'default'), 'default')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertEqual(q.getlist('bar'), [])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar'])
self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
self.assertTrue(q.has_key('foo'))
self.assertTrue('foo' in q)
self.assertFalse(q.has_key('bar'))
self.assertFalse('bar' in q)
self.assertEqual(q.items(), [(u'foo', u'bar')])
self.assertEqual(q.lists(), [(u'foo', [u'bar'])])
self.assertEqual(q.keys(), ['foo'])
self.assertEqual(q.values(), ['bar'])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
self.assertRaises(AttributeError, q.pop, 'foo')
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
self.assertEqual(q.urlencode(), 'foo=bar')
def _parse_response(self, response):
"""Turn the PayPal response into a dict"""
q = QueryDict(response, encoding='UTF-8').dict()
tmp = {}
for k,v in q.items():
tmp.update({k.lower(): v})
return tmp
def _get_initial_query_dict(self, qdict):
if not qdict:
qdict = QueryDict(None, mutable=True)
elif isinstance(qdict, QueryDict):
qdict = qdict.copy()
elif isinstance(qdict, basestring):
if qdict.startswith('?'):
qdict = qdict[1:]
qdict = QueryDict(qdict, mutable=True)
else:
# Accept any old dict or list of pairs.
try:
pairs = qdict.items()
except:
pairs = qdict
qdict = QueryDict(None, mutable=True)
# Enter each pair into QueryDict object:
try:
for k, v in pairs:
# Convert values to unicode so that detecting
# membership works for numbers.
if isinstance(v, (list, tuple)):
for e in v:
qdict.appendlist(k, unicode(e))
else:
qdict.appendlist(k, unicode(v))
except:
# Wrong data structure, qdict remains empty.
pass
return qdict
def _get_initial_query_dict(self, qdict):
if not qdict:
qdict = QueryDict(None, mutable=True)
elif isinstance(qdict, QueryDict):
qdict = qdict.copy()
elif isinstance(qdict, basestring):
if qdict.startswith('?'):
qdict = qdict[1:]
qdict = QueryDict(qdict, mutable=True)
else:
# Accept any old dict or list of pairs.
try:
pairs = qdict.items()
except:
pairs = qdict
qdict = QueryDict(None, mutable=True)
# Enter each pair into QueryDict object:
try:
for k, v in pairs:
# Convert values to unicode so that detecting
# membership works for numbers.
if isinstance(v, (list, tuple)):
for e in v:
qdict.appendlist(k,unicode(e))
else:
qdict.appendlist(k, unicode(v))
except:
# Wrong data structure, qdict remains empty.
pass
return qdict
def verify_auth_token(data):
"""
Verifies a Auth Token in a QueryDict. Returns a
django.contrib.auth.models.User instance if successful or False.
"""
if 'auth_token' not in data:
return False
if 'request_token' not in data:
return False
auth_token = data['auth_token']
params = [('auth_token', auth_token), ('key', settings.SIMPLE_SSO_KEY)]
signature = build_signature(params, settings.SIMPLE_SSO_SECRET)
params.append(('signature', signature))
url = urljoin(settings.SIMPLE_SSO_SERVER, 'verify') + '/'
response = requests.get(url, params=dict(params))
if response.status_code != 200:
return False
data = QueryDict(response.content)
if 'signature' not in data:
return False
if 'user' not in data:
return False
params = [(key, value) for key,value in data.items() if key != 'signature']
if not verify_signature(params, data['signature'], settings.SIMPLE_SSO_SECRET):
return False
return load_json_user(data['user'])
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict('vote=yes&vote=no')
self.assertEqual(q['vote'], u'no')
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
self.assertEqual(q.get('vote', 'default'), u'no')
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.getlist('vote'), [u'yes', u'no'])
self.assertEqual(q.getlist('foo'), [])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
self.assertEqual(q.has_key('vote'), True)
self.assertEqual('vote' in q, True)
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(q.items(), [(u'vote', u'no')])
self.assertEqual(q.lists(), [(u'vote', [u'yes', u'no'])])
self.assertEqual(q.keys(), [u'vote'])
self.assertEqual(q.values(), [u'no'])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
self.assertRaises(AttributeError, q.pop, 'foo')
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
self.assertRaises(AttributeError, q.__delitem__, 'vote')
def test_single_key_value(self):
"""Test QueryDict with one key/value pair"""
q = QueryDict("foo=bar")
self.assertEqual(q["foo"], "bar")
self.assertRaises(KeyError, q.__getitem__, "bar")
self.assertRaises(AttributeError, q.__setitem__, "something", "bar")
self.assertEqual(q.get("foo", "default"), "bar")
self.assertEqual(q.get("bar", "default"), "default")
self.assertEqual(q.getlist("foo"), ["bar"])
self.assertEqual(q.getlist("bar"), [])
self.assertRaises(AttributeError, q.setlist, "foo", ["bar"])
self.assertRaises(AttributeError, q.appendlist, "foo", ["bar"])
self.assertTrue(q.has_key("foo"))
self.assertTrue("foo" in q)
self.assertFalse(q.has_key("bar"))
self.assertFalse("bar" in q)
self.assertEqual(q.items(), [(u"foo", u"bar")])
self.assertEqual(q.lists(), [(u"foo", [u"bar"])])
self.assertEqual(q.keys(), ["foo"])
self.assertEqual(q.values(), ["bar"])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {"foo": "bar"})
self.assertRaises(AttributeError, q.pop, "foo")
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, "foo", "bar")
self.assertEqual(q.urlencode(), "foo=bar")
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict("vote=yes&vote=no")
self.assertEqual(q["vote"], u"no")
self.assertRaises(AttributeError, q.__setitem__, "something", "bar")
self.assertEqual(q.get("vote", "default"), u"no")
self.assertEqual(q.get("foo", "default"), "default")
self.assertEqual(q.getlist("vote"), [u"yes", u"no"])
self.assertEqual(q.getlist("foo"), [])
self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
self.assertRaises(AttributeError, q.appendlist, "foo", ["bar"])
self.assertEqual(q.has_key("vote"), True)
self.assertEqual("vote" in q, True)
self.assertEqual(q.has_key("foo"), False)
self.assertEqual("foo" in q, False)
self.assertEqual(q.items(), [(u"vote", u"no")])
self.assertEqual(q.lists(), [(u"vote", [u"yes", u"no"])])
self.assertEqual(q.keys(), [u"vote"])
self.assertEqual(q.values(), [u"no"])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {"foo": "bar"})
self.assertRaises(AttributeError, q.pop, "foo")
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, "foo", "bar")
self.assertRaises(AttributeError, q.__delitem__, "vote")
def verify_auth_token(data):
"""
Verifies a Auth Token in a QueryDict. Returns a
django.contrib.auth.models.User instance if successful or False.
"""
if "auth_token" not in data:
return False
if "request_token" not in data:
return False
auth_token = data["auth_token"]
params = [("auth_token", auth_token), ("key", settings.SIMPLE_SSO_KEY)]
signature = build_signature(params, settings.SIMPLE_SSO_SECRET)
params.append(("signature", signature))
url = urljoin(settings.SIMPLE_SSO_SERVER, "verify") + "/"
response = requests.get(url, dict(params))
if response.status_code != 200:
return False
data = QueryDict(response.content)
if "signature" not in data:
return False
if "user" not in data:
return False
params = [(key, value) for key, value in data.items() if key != "signature"]
if not verify_signature(params, data["signature"], settings.SIMPLE_SSO_SECRET):
return False
return load_json_user(data["user"])
def put_item(self, request, id):
POST = QueryDict(request.body)
order = self.model.objects.get(id=id)
for prop, val in POST.items():
if prop not in self.immutable_fields:
setattr(order, prop, val)
order.save()
return ok(self.label, result=order)
def getQueryStringValueByKey(queryString, searchKey, defaultValue):
queryDict = QueryDict(queryString)
for key, value in queryDict.items():
if key.lower() == searchKey.lower():
defaultValue = value
break
return defaultValue
def query_list(self, obj):
try:
params = QueryDict(obj.query)
except:
return "Bad query"
return "<table>%s</table>" % (''.join([
"<tr><td>%s</td><td>%s</td></tr>" % i
for i in sorted(params.items())
]))
def query(request, **kwargs):
entries = Entry.objects.accessibles(request.user)
queries = QueryDict('').copy()
queries.update(kwargs)
queries.update(request.GET)
for k,v in queries.items():
if k in ('cate', 'cat', 'c', 'category'):
entries = entries.filter(category=int(v))
if k in ('tag', 't'):
entries = entries.filter(tags=int(v))
if k in ('year', 'y'):
entries = entries.filter(created__year=v)
if k in ('month', 'm'):
entries = entries.filter(created__month=v)
if k in ('day', 'd'):
entries = entries.filter(created__day=v)
if k in ('ym', 'ymd'):
parts = re.split('[-\.\/]', v)
year,month,day = parts[0],parts[1],len(parts) is 3 and parts[2] or None
entries = entries.filter(created__year=year, created__month=month)
if day:
entries = entries.filter(created__day=day)
if k == 'search':
q = Q(pk=-1) # empty queryset
for f in search_fields:
q |= Q(**{'%s__contains' % f: v})
entries = entries.filter(q)
try:
page = int(queries.get('page', 1))
if page == 0: page = 1
except ValueError:
page = 1
paginator = Paginator(entries, ezsettings.get('blog.articles_per_page', 10))
try:
entries = paginator.page(page)
except (EmptyPage, PageNotAnInteger):
entries = paginator.page(paginator.num_pages)
context = {
'entry_list': entries,
'paginator': paginator,
'current_page': entries.number,
'current_url': request.get_full_path(), # 当前页面URL
}
return render_to_response('blog/list.html', context,
context_instance=RequestContext(request, processors=[_base_context]))
def getQueryStringValueByKey(queryString, searchKey, defaultValue):
queryDict = QueryDict(queryString)
for key, value in queryDict.items():
if key.lower() == searchKey.lower():
defaultValue = value
break
return defaultValue
def initial_redirect_should_preserve_querystring(self):
querystring = {'getvar1': 'getval1', 'getvar2': 'getval2'}
response = self.client.get(self.url, querystring)
assert response.status_code == 302
# Test for proper redirect GET parameters
location = response['Location']
assert location.find('?') != -1
querydict = QueryDict(location[location.find('?') + 1:])
assert dict(querydict.items()) == querystring
def test_immutable_basic_operations(self):
q = QueryDict()
self.assertEqual(q.getlist('foo'), [])
self.assertNotIn('foo', q)
self.assertEqual(list(q.items()), [])
self.assertEqual(list(q.lists()), [])
self.assertEqual(list(q.keys()), [])
self.assertEqual(list(q.values()), [])
self.assertEqual(len(q), 0)
self.assertEqual(q.urlencode(), '')
def test_initial_call_with_params(self):
get_params = {'getvar1': 'getval1', 'getvar2': 'getval2'}
response = self.client.get(reverse('%s_start' % self.wizard_urlname), get_params)
self.assertEqual(response.status_code, 302)
# Test for proper redirect GET parameters
location = response['Location']
self.assertNotEqual(location.find('?'), -1)
querydict = QueryDict(location[location.find('?') + 1:])
self.assertEqual(dict(querydict.items()), get_params)
def query_transform(request, **kwargs):
updated = request.GET.copy()
previous = request.META.get('HTTP_REFERER')
dict_prev = QueryDict('', mutable=True)
dict_prev.update(dict(parse.parse_qsl(parse.urlsplit(previous).query)))
for k, v in dict_prev.items():
updated[k] = v
for k, v in kwargs.items():
updated[k] = v
print(updated.urlencode())
return updated.urlencode()
def modify(request, object):
if request.method == "PATCH":
data = QueryDict(request.META["QUERY_STRING"]).dict()
#loop from https://stackoverflow.com/questions/1576664/how-to-update-multiple-fields-of-a-django-model-instance
for (key, value) in data.items():
setattr(object, key, value)
object.save() #save the modified object
return JsonResponse({"message": "PATCHed"})
if request.method == "DELETE":
object.delete()
return JsonResponse({"message": "DELETEd"})
def save(self, *args, **kwargs):
allowed_filters = ["qf=", 'hfq=', "q=", "hqf[]=", "qf[]="]
if any(key in self.query for key in allowed_filters):
# create the proper format string
filter_list = []
query_dict = QueryDict(query_string=self.query.split("?", maxsplit=1)[-1])
for k, v in query_dict.items():
if any([key.startswith(k) for key in allowed_filters]) and v:
applied_filter = query_dict.getlist(k)
filter_list.extend(applied_filter)
self.query = ";;;".join(["\"{}\"".format(k) for k in filter_list])
super(VirtualCollection, self).save(*args, **kwargs)
def load_modernizr_from_storage(self, request):
data = None
if settings.MODERNIZR_STORAGE == 'cookie':
if settings.MODERNIZR_COOKIE_NAME in request.COOKIES:
data = QueryDict(request.COOKIES[settings.MODERNIZR_COOKIE_NAME])
elif settings.MODERNIZR_STORAGE == 'session':
data = request.session.get(settings.MODERNIZR_SESSION_KEY)
if data is not None:
request.modernizr = dict([(k, bool(int(v))) for k,v in data.items()])
else:
request.modernizr = None
def test_query_string_has_too_many_keys(self):
print "test_query_string_has_too_many_keys"
qstr = self.generate_attack_query_string()
print "Query string length: %.3f MB" % (len(qstr) / 1024 / 1024.0)
print "Start parse"
tstart = datetime.now()
q = QueryDict(qstr)
tend = datetime.now()
print "Finish parse use:" + str(tend - tstart)
from django.http.fast_parse_qsl import MAX_PARAMS_KEYS
self.assertEquals(MAX_PARAMS_KEYS, len(q.items()))
def put_item(self, request, *args, **kwargs):
if not self.allow_put_item:
return method_not_allowed()
try:
instance = self.model.objects.get(**kwargs)
except ObjectDoesNotExist:
return not_found()
POST = QueryDict(request.body)
for prop, val in POST.items():
if prop not in self.immutable_fields:
setattr(instance, prop, val)
instance.save()
return ok(self.label, result=instance)
def setup(self):
BaseWidget.setup(self)
bookmark = self.cleaned_data['bookmark']
model = bookmark.content_type.model_class()
data = QueryDict(bookmark.query)
self.bookmark = bookmark
if not self.title:
self.title = unicode(bookmark)
req = self.make_get_request("", data.items())
self.list_view = self.get_view_class(ListAdminView, model, list_per_page=10, list_editable=[])(req)
def modify(request, obj):
if request.method == "PATCH":
data = QueryDict(request.META["QUERY_STRING"]).dict()
# following loop from https://stackoverflow.com/questions/1576664/how-to-update-multiple-fields-of-a-django-model-instance
for (key, value) in data.items():
setattr(obj, key, value)
obj.save()
response = {"Message":"UPDATED (200)"}
elif request.method == "DELETE":
obj.delete()
response = {"Message":"DELETED (200)"}
else:
response = {"Message":"WRONG REQUEST (400)"}
return JsonResponse(response)
def put(self, *args, **kwargs):
try:
put = QueryDict(self.request.body)
req_data = {}
for k, v in put.items():
req_data[k] = v
tb_name = req_data.pop('table_name')
ex_data, latest_file = read_user_excel(
self.request.user, self.request.user.is_superuser)
df = dict_to_dataframe(req_data)
excel_update(ex_data, df, latest_file)
return HttpResponse(json.dumps("Record added successfully."))
except:
raise Exception("Fail to add record.")
def setup(self):
BaseWidget.setup(self)
bookmark = self.cleaned_data['bookmark']
model = bookmark.content_type.model_class()
data = QueryDict(bookmark.query)
self.bookmark = bookmark
if not self.title:
self.title = smart_text(bookmark)
req = self.make_get_request("", data.items())
self.list_view = self.get_view_class(
ListAdminView, model, list_per_page=10, list_editable=[])(req)
def post(self, request):
ret = {'status': 0, 'errmsg': 'ok'}
data = QueryDict(request.body)
data = dict(data.items())
try:
server = Server(**data)
server.save()
except Exception as e:
msg = "user {} add server error:{}".format(request.user.username,
e.args)
logger.error(msg)
ret['status'] = 1
ret['errmsg'] = msg
return JsonResponse(ret, safe=True)
def prepare_parameters(self, params: QueryDict) -> dict:
new_params = {}
# This converts a query dict into a normal dictionary
# However, it preserves lists if a list of query parameters is given
params = {k: v[0] if len(v) == 1 else v for k, v in params.lists()}
for key, value in params.items():
if value in ["true", "True"]:
new_params[key] = True
elif value in ["false", "False"]:
new_params[key] = False
else:
new_params[key] = value
return new_params
def put_item(self, request, *args, **kwargs):
if not self.allow_put_item:
return method_not_allowed()
try:
instance = self.model.objects.get(**kwargs)
except ObjectDoesNotExist:
return not_found()
POST = QueryDict(request.body)
for prop, val in POST.items():
if prop not in self.immutable_fields:
setattr(instance, prop, val)
try:
instance.save()
except IntegrityError, e:
return conflict()
def assertResponseErrorsReported(self, rsps, expected_error_dicts): # noqa
for expected_error_dict in expected_error_dicts:
expected_error_dict.update({
'v': '1',
'tid': DEFAULT_SETTINGS['GOOGLE_ANALYTICS_ID'],
't': 'event',
})
reported_error_dicts = []
for error_line in rsps.calls[0].request.body.splitlines():
if not error_line:
continue
error_params = QueryDict(error_line)
error_params = {k: v for k, v in error_params.items()}
reported_error_dicts.append(error_params)
self.assertEqual(len(reported_error_dicts), len(expected_error_dicts))
error_dict_pairs = zip(reported_error_dicts, expected_error_dicts)
for reported_error_dict, expected_error_dict in error_dict_pairs:
self.assertDictEqual(reported_error_dict, expected_error_dict)
def add_url_parameters(value, arg):
""" Add GET parameters to URL string.
Usage:
{{ request.get_full_path|add_url_parameters:"mode=list&limit=9" }}
"""
if not isinstance(arg, basestring):
arg = unicode(arg)
from django.http import QueryDict, parse_qsl
parts = value.split('?')
path = parts[0]
q = '&'.join(parts[1:])
args = QueryDict(q).copy()
new_args = parse_qsl(arg or '')
for (k, v) in new_args:
args.update({k: v})
s = lambda x, y: "%s=%s" % (x, y) if y else "%s" % x
q = '&'.join([s(k, v) for (k, v) in args.items()])
return '?'.join([path, q])
def test_single_key_value(self):
"""Test QueryDict with one key/value pair"""
q = QueryDict('foo=bar')
self.assertEqual(q['foo'], 'bar')
with self.assertRaises(KeyError):
q.__getitem__('bar')
with self.assertRaises(AttributeError):
q.__setitem__('something', 'bar')
self.assertEqual(q.get('foo', 'default'), 'bar')
self.assertEqual(q.get('bar', 'default'), 'default')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertEqual(q.getlist('bar'), [])
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar'])
with self.assertRaises(AttributeError):
q.appendlist('foo', ['bar'])
self.assertIn('foo', q)
self.assertNotIn('bar', q)
self.assertEqual(list(q), ['foo'])
self.assertEqual(list(q.items()), [('foo', 'bar')])
self.assertEqual(list(q.lists()), [('foo', ['bar'])])
self.assertEqual(list(q.keys()), ['foo'])
self.assertEqual(list(q.values()), ['bar'])
self.assertEqual(len(q), 1)
with self.assertRaises(AttributeError):
q.update({'foo': 'bar'})
with self.assertRaises(AttributeError):
q.pop('foo')
with self.assertRaises(AttributeError):
q.popitem()
with self.assertRaises(AttributeError):
q.clear()
with self.assertRaises(AttributeError):
q.setdefault('foo', 'bar')
self.assertEqual(q.urlencode(), 'foo=bar')
