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_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(), [('foo', 'bar')])
self.assertEqual(q.lists(), [('foo', ['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 urlparams(url_, fragment=None, query_dict=None, **query):
"""
Add a fragment and/or query parameters to a URL.
New query params will be appended to exising parameters, except duplicate
names, which will be replaced.
"""
url_ = urlparse.urlparse(url_)
fragment = fragment if fragment is not None else url_.fragment
q = url_.query
new_query_dict = QueryDict(smart_str(q), mutable=True) if q else QueryDict("", mutable=True)
if query_dict:
for k, l in query_dict.lists():
new_query_dict[k] = None # Replace, don't append.
for v in l:
new_query_dict.appendlist(k, v)
for k, v in query.items():
# Replace, don't append.
if isinstance(v, list):
new_query_dict.setlist(k, v)
else:
new_query_dict[k] = v
query_string = urlencode([(k, v) for k, l in new_query_dict.lists() for v in l if v is not None])
new = urlparse.ParseResult(url_.scheme, url_.netloc, url_.path, url_.params, query_string, fragment)
return new.geturl()
def delete(self, request, *args, **kwargs):
# Dict delete
qd = QueryDict(request.body)
DELETE_DICT = {k: v[0] if len(v) == 1 else v for k, v in qd.lists()}
# Get params
forum = DELETE_DICT.get("forum")
idtopic = DELETE_DICT.get("idtopic")
# Previouly verify that exists the topic
topic = get_object_or_404(
models.Topic, idtopic=idtopic, user_id=request.user.id
)
# Get data topic
iduser_topic = topic.user_id
title_topic = topic.title
# If my user so delete
if request.user.id == iduser_topic:
utils.remove_folder_attachment(idtopic)
models.Topic.objects.filter(
idtopic=idtopic, user_id=iduser_topic
).delete()
messages.success(
request, _("The topic '%(topic)s' was successfully deleted")
% {'topic': title_topic}
)
else:
raise HttpResponse(status=404)
return HttpResponse(status=200)
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_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict('vote=yes&vote=no')
self.assertEqual(q['vote'], 'no')
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
self.assertEqual(q.get('vote', 'default'), 'no')
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.getlist('vote'), ['yes', '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(), [('vote', 'no')])
self.assertEqual(q.lists(), [('vote', ['yes', 'no'])])
self.assertEqual(q.keys(), ['vote'])
self.assertEqual(q.values(), ['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 __init__(self, request, model, lite=False, *args, **kwargs):
new_get = None
setattr(self, 'user', getattr(request, 'user', None))
try:
path = request.get_full_path()
path_index = path.index("?")
new_get = QueryDict(path[path_index + 1:], mutable=True)
if lite:
self.GET = QueryDict("")
return
for key, value in new_get.lists():
if not key.startswith('__'):
key_with_filter = '__'.join(key.split('__')[:-1])
try:
model_field, field = get_field_from_model(model, key_with_filter, separated_field='__')
adaptor = get_adaptor(field)
adaptor = adaptor(model, field, key_with_filter)
value, new_get = adaptor.change_value(value, key, new_get)
if key in new_get:
new_get.setlist(key, value)
except models.FieldDoesNotExist:
del new_get[key]
self.GET = new_get
except ValueError:
self.GET = QueryDict("")
def delete(self, request):
"""删除地址"""
DELETE = QueryDict(request.body)
id = eval(list(dict(DELETE.lists()).keys())[0])['id']
if Address.objects.del_address(id):
return JsonResponse({'message': 'success'})
else:
return JsonResponse({'message': '删除失败'})
def delete(self, request):
qd = QueryDict(request.body)
delete_dict = {k: v[0] if len(v) == 1 else v for k, v in qd.lists()}
user_id = delete_dict.get('user_id', '')
user = User.objects.get(pk=user_id)
user.is_active = False
user.save()
return restful.ok()
def qdict_to_dict(qdict: QueryDict) -> dict:
"""Convert a Django QueryDict to a Python dict.
Single-value fields are put in directly, and for multi-value fields, a list
of all values is stored at the field's key.
"""
return {k: v[0] if len(v) == 1 else v for k, v in qdict.lists()}
def clean_search(self):
# Remove all empty elements of search field
# Django `QueryDict` uses keep_blank_values=True
# in parse_qsl that keeps empty values as [u'']
# which is not in our use case
# Below, we remove these values, and only keep setted ones.
data = self.cleaned_data['search']
q = QueryDict(data, mutable=True)
[q.pop(elt[0]) for elt in q.lists() if elt[1] == [u'']]
return q.urlencode()
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 put(self, request):
qd = QueryDict(request.body)
put_dict = {k: v[0] if len(v) == 1 else v for k, v in qd.lists()}
category_id = put_dict.get("category_id", "")
category_name = put_dict.get("category_name", "")
nums = put_dict.get("nums", "")
category = NewsCategory.objects.get(pk=category_id)
category.name = category_name
category.nums = nums
category.save()
return restful.ok()
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_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 _transform_query_params(self, view, query_params: QueryDict) -> QueryDict:
if not self._is_camel_case(view):
return query_params
# data can be a regular dict if it's coming from a serializer
if hasattr(query_params, "lists"):
data = dict(query_params.lists())
else:
data = query_params
transformed = underscoreize(data)
return QueryDict(urlencode(transformed, doseq=True))
def put(self, request, banner_id):
'''修改轮播图'''
qd = QueryDict(request.body)
put_dict = {k: v[0] if len(v) == 1 else v for k, v in qd.lists()}
banner = Banner.objects.get(pk=banner_id)
if not banner:
return restful.params_error(message='轮播图不存在')
position = put_dict.get('position')
link_url = put_dict.get('link_url')
# Banner.objects.filter(pk=banner_id).update(position=position, link_url=link_url)
banner.position = position
banner.link_url = link_url
banner.save()
return restful.ok()
def translate_query_string(query_string):
word_query = QueryDict(query_string)
new_query_string = u''
for i in word_query.lists():
modelstring = i[0].strip().lower()
values = i[1]
if modelstring in fixed_fields:
new_query_string += "&" + camelcase(modelstring) + "=" + values[0]
elif modelstring[0:7] == u'incluir':
new_query_string += "&" + camelcase(modelstring) + "=on"
else:
modelname = ' '.join(modelstring.split()[1:])
appname = modelstring.split()[0]
ctype_list = ContentType.objects.filter(app_label=appname,
name=modelname)
if len(ctype_list) > 0:
ctype = ctype_list[0]
if len(ctype_list) > 1:
name_length = len(ctype.name)
for i in ctype_list:
if len(i.name) < name_length:
ctype = i
name_length = len(ctype.name)
model_class = ctype.model_class()
for b in values:
value = b.strip()
d = model_class.objects.filter(nombre__startswith=value)
if len(d) > 0:
variable_value = d[0]
if len(d) > 1:
name_length = len(variable_value.nombre)
for i in d:
if len(i.nombre) < name_length:
variable_value = i
name_length = len(variable_value.nombre)
new_query_string += "&" + camelcase(
modelstring) + "=" + str(variable_value.pk)
else:
try:
int(value)
e = model_class.objects.filter(pk=int(value))
if len(e) > 0:
new_query_string += "&" + camelcase(
modelstring) + "=" + str(value)
except ValueError:
pass
else:
new_query_string += "TEST" + modelstring + "TEST"
new_query_string = new_query_string.lstrip("&")
return new_query_string
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 home(request):
# context_instance = RequestContext(request)
if request.method == 'GET':
return render_to_response('index.html')
elif request.method == 'POST':
queryDict = QueryDict()
queryDict = request.POST
a = dict(queryDict.lists())
comment = str(a.get('text')).split("'")[1].decode('utf-8')
author = str(a.get('author')).split("'")[1].decode('utf-8')
print 'comment - ' + comment
print 'author - ' + author
p1 = Comments(user_id=author, post_id='1', comment=comment)
p1.save()
return render_to_response('index.html')
def get_url_from_cleaned_data(region, data):
query = QueryDict(mutable=True)
for key, values in data.items():
if key in ['deal_type']:
continue
if not hasattr(values, '__iter__'):
values = [values]
for value in values:
if value:
# getattr для обработки объектов типа Region
query.appendlist(key, unicode(getattr(value, 'id', value)))
return u'?%s' % get_sorted_urlencode(query.lists()) if len(
query) else ''
def _get_flattened(self, params):
""" Returns a QueryDict of parameters with single-element lists unwrapped to point to the sole element directly.
"""
if params:
params = QueryDict(params, encoding='utf-8')
out = {}
for key, value in params.lists():
if len(value) > 1:
out[key] = value
else:
out[key] = value[0]
else:
out = {}
return out
def translate_query_string(query_string):
word_query=QueryDict(query_string)
new_query_string=u''
for i in word_query.lists():
modelstring=i[0].strip().lower()
values= i[1]
if modelstring in fixed_fields:
new_query_string+="&"+camelcase(modelstring)+"="+values[0]
elif modelstring[0:7]==u'incluir':
new_query_string+="&"+camelcase(modelstring)+"=on"
else:
modelname=' '.join(modelstring.split()[1:])
appname=modelstring.split()[0]
ctype_list = ContentType.objects.filter(app_label=appname,name=modelname)
if len(ctype_list) > 0:
ctype=ctype_list[0]
if len(ctype_list) > 1:
name_length=len(ctype.name)
for i in ctype_list:
if len(i.name) < name_length:
ctype=i
name_length=len(ctype.name)
model_class=ctype.model_class()
for b in values:
value=b.strip()
d=model_class.objects.filter(nombre__startswith=value)
if len(d) > 0:
variable_value=d[0]
if len(d) > 1:
name_length=len(variable_value.nombre)
for i in d:
if len(i.nombre)<name_length:
variable_value=i
name_length=len(variable_value.nombre)
new_query_string+="&"+camelcase(modelstring)+"="+str(variable_value.pk)
else:
try:
int(value)
e=model_class.objects.filter(pk=int(value))
if len(e) > 0:
new_query_string+="&"+camelcase(modelstring)+"="+str(value)
except ValueError:
pass
else:
new_query_string+="TEST"+modelstring+"TEST"
new_query_string=new_query_string.lstrip("&")
return new_query_string
def home(request):
# context_instance = RequestContext(request)
if request.method == 'GET':
return render_to_response('index.html')
elif request.method == 'POST':
queryDict = QueryDict()
queryDict = request.POST
a = dict(queryDict.lists())
comment = str(a.get('text')).split("'")[1].decode('utf-8')
author = str(a.get('author')).split("'")[1].decode('utf-8')
print 'comment - ' + comment
print 'author - ' + author
p1 = Comments(user_id=author,
post_id='1',
comment=comment)
p1.save()
return render_to_response('index.html')
def put(self, request):
qd = QueryDict(request.body)
put_dict = {k: v[0] if len(v) == 1 else v for k, v in qd.lists()}
form = UserManageForm(put_dict)
if form.is_valid():
password = put_dict.get('password', '')
# user_id = put_dict.get('userid','')
# user_name = put_dict.get('username','')
# telephone = put_dict.get('telephone','')
# email = put_dict.get('email','')
# user = User.objects.filter(pk=user_id).update(username=user_name,telephone=telephone,email=email)
user = form.save(commit=False)
user.set_password(password)
user.save()
return restful.ok()
else:
return restful.params_error(message=form.get_first_error())
def put(self, request, news_id):
qd = QueryDict(request.body)
put_dict = {k: v[0] if len(v) == 1 else v for k, v in qd.lists()}
form = WriteNewsForm(put_dict)
if form.is_valid():
title = form.cleaned_data.get('title')
desc = form.cleaned_data.get('desc')
thumbnail = form.cleaned_data.get('thumbnail')
content = form.cleaned_data.get('content')
category_id = form.cleaned_data.get('category')
try:
category = NewsCategory.objects.get(pk=category_id)
News.objects.filter(pk=news_id).updata(title=title, desc=desc, thumbnail=thumbnail, content=content, category=category, author=request.user)
except Exception as err:
print(err)
return restful.server_error(message="服务器内部错误")
else:
return restful.ok()
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'], 'no')
with self.assertRaises(AttributeError):
q.__setitem__('something', 'bar')
self.assertEqual(q.get('vote', 'default'), 'no')
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.getlist('vote'), ['yes', 'no'])
self.assertEqual(q.getlist('foo'), [])
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar', 'baz'])
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar', 'baz'])
with self.assertRaises(AttributeError):
q.appendlist('foo', ['bar'])
self.assertIn('vote', q)
self.assertNotIn('foo', q)
self.assertEqual(list(q), ['vote'])
self.assertEqual(list(q.items()), [('vote', 'no')])
self.assertEqual(list(q.lists()), [('vote', ['yes', 'no'])])
self.assertEqual(list(q.keys()), ['vote'])
self.assertEqual(list(q.values()), ['no'])
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')
with 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')
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')
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'], 'no')
with self.assertRaises(AttributeError):
q.__setitem__('something', 'bar')
self.assertEqual(q.get('vote', 'default'), 'no')
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.getlist('vote'), ['yes', 'no'])
self.assertEqual(q.getlist('foo'), [])
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar', 'baz'])
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar', 'baz'])
with self.assertRaises(AttributeError):
q.appendlist('foo', ['bar'])
self.assertIn('vote', q)
self.assertNotIn('foo', q)
self.assertEqual(list(q), ['vote'])
self.assertEqual(list(q.items()), [('vote', 'no')])
self.assertEqual(list(q.lists()), [('vote', ['yes', 'no'])])
self.assertEqual(list(q.keys()), ['vote'])
self.assertEqual(list(q.values()), ['no'])
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')
with 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')
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')
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")
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"], "no")
with self.assertRaises(AttributeError):
q.__setitem__("something", "bar")
self.assertEqual(q.get("vote", "default"), "no")
self.assertEqual(q.get("foo", "default"), "default")
self.assertEqual(q.getlist("vote"), ["yes", "no"])
self.assertEqual(q.getlist("foo"), [])
with self.assertRaises(AttributeError):
q.setlist("foo", ["bar", "baz"])
with self.assertRaises(AttributeError):
q.setlist("foo", ["bar", "baz"])
with self.assertRaises(AttributeError):
q.appendlist("foo", ["bar"])
self.assertIn("vote", q)
self.assertNotIn("foo", q)
self.assertEqual(list(q), ["vote"])
self.assertEqual(list(q.items()), [("vote", "no")])
self.assertEqual(list(q.lists()), [("vote", ["yes", "no"])])
self.assertEqual(list(q.keys()), ["vote"])
self.assertEqual(list(q.values()), ["no"])
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")
with self.assertRaises(AttributeError):
q.__delitem__("vote")
def clean_search_querystring(querystring):
"""
- remove starting '?' if it exists
- remove empty params
"""
if not querystring:
return querystring
# Sometimes the querystring contains a leading '?' character
# and we don't want it here.
querystring = querystring.strip('?')
# Re-build the querydict without the empty params
querydict = QueryDict(querystring).copy()
querydict_cleaned = QueryDict('', mutable=True)
for k, v in querydict.lists():
values_without_empty = list(filter(None, v))
if values_without_empty:
querydict_cleaned.setlist(k, values_without_empty)
# Transform the cleaned querydict into a querystring
querystring_cleaned = querydict_cleaned.urlencode()
return querystring_cleaned
def test_basic_mutable_operations(self):
q = QueryDict(mutable=True)
q["name"] = "john"
self.assertEqual(q.get("foo", "default"), "default")
self.assertEqual(q.get("name", "default"), "john")
self.assertEqual(q.getlist("name"), ["john"])
self.assertEqual(q.getlist("foo"), [])
q.setlist("foo", ["bar", "baz"])
self.assertEqual(q.get("foo", "default"), "baz")
self.assertEqual(q.getlist("foo"), ["bar", "baz"])
q.appendlist("foo", "another")
self.assertEqual(q.getlist("foo"), ["bar", "baz", "another"])
self.assertEqual(q["foo"], "another")
self.assertIn("foo", q)
self.assertCountEqual(q, ["foo", "name"])
self.assertCountEqual(q.items(), [("foo", "another"),
("name", "john")])
self.assertCountEqual(q.lists(), [("foo", ["bar", "baz", "another"]),
("name", ["john"])])
self.assertCountEqual(q.keys(), ["foo", "name"])
self.assertCountEqual(q.values(), ["another", "john"])
q.update({"foo": "hello"})
self.assertEqual(q["foo"], "hello")
self.assertEqual(q.get("foo", "not available"), "hello")
self.assertEqual(q.getlist("foo"), ["bar", "baz", "another", "hello"])
self.assertEqual(q.pop("foo"), ["bar", "baz", "another", "hello"])
self.assertEqual(q.pop("foo", "not there"), "not there")
self.assertEqual(q.get("foo", "not there"), "not there")
self.assertEqual(q.setdefault("foo", "bar"), "bar")
self.assertEqual(q["foo"], "bar")
self.assertEqual(q.getlist("foo"), ["bar"])
self.assertIn(q.urlencode(),
["foo=bar&name=john", "name=john&foo=bar"])
q.clear()
self.assertEqual(len(q), 0)
def test_basic_mutable_operations(self):
q = QueryDict(mutable=True)
q['name'] = 'john'
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.get('name', 'default'), 'john')
self.assertEqual(q.getlist('name'), ['john'])
self.assertEqual(q.getlist('foo'), [])
q.setlist('foo', ['bar', 'baz'])
self.assertEqual(q.get('foo', 'default'), 'baz')
self.assertEqual(q.getlist('foo'), ['bar', 'baz'])
q.appendlist('foo', 'another')
self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
self.assertEqual(q['foo'], 'another')
self.assertIn('foo', q)
self.assertCountEqual(q, ['foo', 'name'])
self.assertCountEqual(q.items(), [('foo', 'another'),
('name', 'john')])
self.assertCountEqual(q.lists(), [('foo', ['bar', 'baz', 'another']),
('name', ['john'])])
self.assertCountEqual(q.keys(), ['foo', 'name'])
self.assertCountEqual(q.values(), ['another', 'john'])
q.update({'foo': 'hello'})
self.assertEqual(q['foo'], 'hello')
self.assertEqual(q.get('foo', 'not available'), 'hello')
self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another', 'hello'])
self.assertEqual(q.pop('foo'), ['bar', 'baz', 'another', 'hello'])
self.assertEqual(q.pop('foo', 'not there'), 'not there')
self.assertEqual(q.get('foo', 'not there'), 'not there')
self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
self.assertEqual(q['foo'], 'bar')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertIn(q.urlencode(),
['foo=bar&name=john', 'name=john&foo=bar'])
q.clear()
self.assertEqual(len(q), 0)
def test_basic_mutable_operations(self):
q = QueryDict('').copy()
q['name'] = 'john'
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.get('name', 'default'), 'john')
self.assertEqual(q.getlist('name'), ['john'])
self.assertEqual(q.getlist('foo'), [])
q.setlist('foo', ['bar', 'baz'])
self.assertEqual(q.get('foo', 'default'), 'baz')
self.assertEqual(q.getlist('foo'), ['bar', 'baz'])
q.appendlist('foo', 'another')
self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
self.assertEqual(q['foo'], 'another')
self.failUnless(q.has_key('foo'))
self.failUnless('foo' in q)
self.assertEqual(q.items(), [(u'foo', u'another'), (u'name', u'john')])
self.assertEqual(q.lists(), [(u'foo', [u'bar', u'baz', u'another']),
(u'name', [u'john'])])
self.assertEqual(q.keys(), [u'foo', u'name'])
self.assertEqual(q.values(), [u'another', u'john'])
self.assertEqual(len(q), 2)
q.update({'foo': 'hello'})
self.assertEqual(q['foo'], 'hello')
self.assertEqual(q.get('foo', 'not available'), 'hello')
self.assertEqual(q.getlist('foo'),
[u'bar', u'baz', u'another', u'hello'])
self.assertEqual(q.pop('foo'), [u'bar', u'baz', u'another', u'hello'])
self.assertEqual(q.pop('foo', 'not there'), 'not there')
self.assertEqual(q.get('foo', 'not there'), 'not there')
self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
self.assertEqual(q['foo'], 'bar')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertEqual(q.urlencode(), 'foo=bar&name=john')
q.clear()
self.assertEqual(len(q), 0)
def test_basic_mutable_operations(self):
q = QueryDict("").copy()
q["name"] = "john"
self.assertEqual(q.get("foo", "default"), "default")
self.assertEqual(q.get("name", "default"), "john")
self.assertEqual(q.getlist("name"), ["john"])
self.assertEqual(q.getlist("foo"), [])
q.setlist("foo", ["bar", "baz"])
self.assertEqual(q.get("foo", "default"), "baz")
self.assertEqual(q.getlist("foo"), ["bar", "baz"])
q.appendlist("foo", "another")
self.assertEqual(q.getlist("foo"), ["bar", "baz", "another"])
self.assertEqual(q["foo"], "another")
self.assertTrue(q.has_key("foo"))
self.assertTrue("foo" in q)
self.assertEqual(q.items(), [(u"foo", u"another"), (u"name", u"john")])
self.assertEqual(q.lists(), [(u"foo", [u"bar", u"baz", u"another"]), (u"name", [u"john"])])
self.assertEqual(q.keys(), [u"foo", u"name"])
self.assertEqual(q.values(), [u"another", u"john"])
self.assertEqual(len(q), 2)
q.update({"foo": "hello"})
self.assertEqual(q["foo"], "hello")
self.assertEqual(q.get("foo", "not available"), "hello")
self.assertEqual(q.getlist("foo"), [u"bar", u"baz", u"another", u"hello"])
self.assertEqual(q.pop("foo"), [u"bar", u"baz", u"another", u"hello"])
self.assertEqual(q.pop("foo", "not there"), "not there")
self.assertEqual(q.get("foo", "not there"), "not there")
self.assertEqual(q.setdefault("foo", "bar"), "bar")
self.assertEqual(q["foo"], "bar")
self.assertEqual(q.getlist("foo"), ["bar"])
self.assertEqual(q.urlencode(), "foo=bar&name=john")
q.clear()
self.assertEqual(len(q), 0)
def test_basic_mutable_operations(self):
q = QueryDict('').copy()
q['name'] = 'john'
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.get('name', 'default'), 'john')
self.assertEqual(q.getlist('name'), ['john'])
self.assertEqual(q.getlist('foo'), [])
q.setlist('foo', ['bar', 'baz'])
self.assertEqual(q.get('foo', 'default'), 'baz')
self.assertEqual(q.getlist('foo'), ['bar', 'baz'])
q.appendlist('foo', 'another')
self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
self.assertEqual(q['foo'], 'another')
self.assertTrue(q.has_key('foo'))
self.assertTrue('foo' in q)
self.assertEqual(q.items(), [(u'foo', u'another'), (u'name', u'john')])
self.assertEqual(q.lists(), [(u'foo', [u'bar', u'baz', u'another']), (u'name', [u'john'])])
self.assertEqual(q.keys(), [u'foo', u'name'])
self.assertEqual(q.values(), [u'another', u'john'])
self.assertEqual(len(q), 2)
q.update({'foo': 'hello'})
self.assertEqual(q['foo'], 'hello')
self.assertEqual(q.get('foo', 'not available'), 'hello')
self.assertEqual(q.getlist('foo'), [u'bar', u'baz', u'another', u'hello'])
self.assertEqual(q.pop('foo'), [u'bar', u'baz', u'another', u'hello'])
self.assertEqual(q.pop('foo', 'not there'), 'not there')
self.assertEqual(q.get('foo', 'not there'), 'not there')
self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
self.assertEqual(q['foo'], 'bar')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertEqual(q.urlencode(), 'foo=bar&name=john')
q.clear()
self.assertEqual(len(q), 0)
def generar_conteo(request):
# Aqui ya se supone que se validó que el request fuera POST y que proviniera del btngenerar.
# Insertar registro en ConteoInventario
estado = Tipo.objects.get(pk=Tipo.objects.filter(
nombre='Ejecutada', grupo='STATUSCONTEO').first().id)
conteo = ConteoInventario(fecha_creacion=datetime.now(),
usuario_creacion=Usuario.objects.get(pk=1),
estado=estado,
fecha_cambio_estado=datetime.now())
conteo.save()
# Capturar la información del formulario e insertar N registros en DetalleProductos
qd = QueryDict(request.body)
for values in qd.lists():
for value in values:
if value == "id":
for valor in values[1]:
# Insercion
guardar_DetalleProductos_Estado_Inicial(conteo, valor)
return conteo.id
def test_basic_mutable_operations(self):
q = QueryDict(mutable=True)
q['name'] = 'john'
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.get('name', 'default'), 'john')
self.assertEqual(q.getlist('name'), ['john'])
self.assertEqual(q.getlist('foo'), [])
q.setlist('foo', ['bar', 'baz'])
self.assertEqual(q.get('foo', 'default'), 'baz')
self.assertEqual(q.getlist('foo'), ['bar', 'baz'])
q.appendlist('foo', 'another')
self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
self.assertEqual(q['foo'], 'another')
self.assertIn('foo', q)
self.assertCountEqual(q, ['foo', 'name'])
self.assertCountEqual(q.items(), [('foo', 'another'), ('name', 'john')])
self.assertCountEqual(q.lists(), [('foo', ['bar', 'baz', 'another']), ('name', ['john'])])
self.assertCountEqual(q.keys(), ['foo', 'name'])
self.assertCountEqual(q.values(), ['another', 'john'])
q.update({'foo': 'hello'})
self.assertEqual(q['foo'], 'hello')
self.assertEqual(q.get('foo', 'not available'), 'hello')
self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another', 'hello'])
self.assertEqual(q.pop('foo'), ['bar', 'baz', 'another', 'hello'])
self.assertEqual(q.pop('foo', 'not there'), 'not there')
self.assertEqual(q.get('foo', 'not there'), 'not there')
self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
self.assertEqual(q['foo'], 'bar')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertIn(q.urlencode(), ['foo=bar&name=john', 'name=john&foo=bar'])
q.clear()
self.assertEqual(len(q), 0)
def delete(self, request, news_id):
qd = QueryDict(request.body)
delete_dict = {k: v[0] if len(v) == 1 else v for k, v in qd.lists()}
def delete(self, request):
qd = QueryDict(request.body)
delete_dict = {k: v[0] if len(v) == 1 else v for k, v in qd.lists()}
category_id = delete_dict.get("category_id", "")
NewsCategory.objects.get(pk=category_id).delete()
return restful.ok()
def RequestDataUnbox(request):
qd = QueryDict(request.body)
return {k: v[0] if len(v) == 1 else v for k, v in qd.lists()}