def __init__(self, data=None, *args, **kwargs):
super(ExpectationForm, self).__init__(*args, **kwargs)
self.user_values = [(x['id'],x['username'])
for x in User.objects.all().values()]
self.servers = LogMessage.objects.all() \
.order_by('server_ip') \
.values('server_ip') \
.distinct()
self.server_values = [(x['server_ip'],x['server_ip'])
for x in self.servers]
if data is None:
data = QueryDict('')
self.fields['severity__in'] = forms.MultipleChoiceField(
required=False,
widget=SelectMultiple(attrs={
'size':'8',
}),
choices=SEVERITY_CHOICES,
initial=data.getlist('severity__in'))
self.fields['application__in'] = forms.MultipleChoiceField(
required=False,
widget=SelectMultiple(attrs={
'size':'8',
}),
choices=self.user_values,
initial=data.getlist('application__in'))
self.fields['server_ip__in'] = forms.MultipleChoiceField(
required=False,
widget=SelectMultiple(attrs={
'size':'8',
}),
choices=self.server_values,
initial=data.getlist('server_ip__in'))
def add_asset_group_api(request):
new_assetgroup_args = QueryDict(request.body)
tags = new_assetgroup_args.getlist('tags')
assets = new_assetgroup_args.getlist('assets')
new_assetgroup_args_dict = QueryDict(request.body).dict()
new_assetgroup_args_dict.update({"owner": request.user})
new_assetgroup_args_dict.pop("tags", None)
new_assetgroup_args_dict.pop("assets", None)
assetgroup = AssetGroup(**new_assetgroup_args_dict)
assetgroup.save()
# Add assets
for asset in assets:
a = Asset.objects.for_user(request.user).filter(id=asset).first()
if a:
assetgroup.assets.add(a)
assetgroup.save()
# Add categories
for cat in tags:
c = AssetCategory.objects.filter(value=cat).first()
if c:
assetgroup.categories.add(c)
assetgroup.save()
return JsonResponse(assetgroup.to_dict())
def _get_filter_clauses_from_querydict(qdict: QueryDict):
filters = {}
for field in qdict:
if "__" in field:
field_name, qualifier = field.split("__", 1)
if qualifier == "in":
# If user specifies multiply ins, take intersection
value = [v.strip() for v in qdict.get(field).split(",")]
if len(qdict.getlist(field)) > 1:
for values in qdict.getlist(field):
value = set(value) & {v.strip() for v in values.split(",")}
value = list(value)
elif len(qdict.getlist(field)) > 1:
raise ValueError("Is does not make sense to have more than 1 value for filter: {}".format(field))
else:
value = qdict.get(field)
else:
value = list(qdict.getlist(field))
field += "__in"
if field in filters:
# Field has already been filtered with a different qualifier
filters[field] = list(set(filters[field]) & set(value))
else:
filters[field] = value
return filters
class ArticleFacetedSearchForm(FacetedSearchForm):
compendium_type = forms.MultipleChoiceField(required=False, choices=choices.ENTRY_TYPES)
primary_research_field = forms.MultipleChoiceField(required=False, choices=choices.RESEARCH_FIELDS)
def __init__(self, *args, **kwargs):
super(ArticleFacetedSearchForm, self).__init__(*args, **kwargs)
self.query_dict = args[0]
if self.query_dict is None:
self.query_dict = QueryDict({})
self.compendium_types = self.query_dict.getlist('compendium_type', [])
self.research_fields = self.query_dict.getlist('primary_research_field', [])
logger.debug('compendium_types %s', self.compendium_types)
logger.debug('research_fields %s', self.research_fields)
def search(self):
sqs = super(ArticleFacetedSearchForm, self).search()
if len(self.compendium_types) > 0 or len(self.research_fields) > 0:
sq = SQ()
for compendium_type in self.compendium_types:
sq.add(SQ(compendium_type=compendium_type), SQ.OR)
for research_field in self.research_fields:
sq.add(SQ(primary_research_field=research_field), SQ.OR)
return sqs.filter(sq)
# otherwise just pass through
return sqs
def _get_filter_clauses_from_querydict(qdict: QueryDict):
filters = {}
for field in qdict:
if "__" in field:
field_name, qualifier = field.split("__", 1)
if qualifier == "in":
# If user specifies multiply ins, take intersection
value = [v.strip() for v in qdict.get(field).split(",")]
if len(qdict.getlist(field)) > 1:
for values in qdict.getlist(field):
value = set(value) & {v.strip() for v in values.split(",")}
value = list(value)
elif len(qdict.getlist(field)) > 1:
raise ValueError("Is does not make sense to have more than 1 value for filter: {}".format(field))
else:
value = qdict.get(field)
else:
value = list(qdict.getlist(field))
field += "__in"
if field in filters:
# Field has already been filtered with a different qualifier
filters[field] = list(set(filters[field]) & set(value))
else:
filters[field] = value
return filters
def convert_post_data_to_formset_data(
snake_formset_name: str,
formset: forms.BaseFormSet,
data: QueryDict
) -> QueryDict:
'''
Convert CamelCased POST data for the given formsets into snake_cased POST data.
'''
snake_cased_data = QueryDict(mutable=True)
camel_formset_name = to_camel_case(snake_formset_name)
total_forms_key = f'{camel_formset_name}-{formsets.TOTAL_FORM_COUNT}'
total_forms = _get_safe_int(
data.get(total_forms_key, ''), default=0, max_value=formsets.DEFAULT_MAX_NUM)
for special_key in SPECIAL_FORMSET_FIELD_NAMES:
snake_key = f'{snake_formset_name}-{special_key}'
camel_key = f'{camel_formset_name}-{special_key}'
value = data.getlist(camel_key)
_set_list_if_nonempty(snake_cased_data, snake_key, value)
form = get_formset_form(formset)
for i in range(total_forms):
for snake_field_name in form.fields:
snake_key = f'{snake_formset_name}-{i}-{snake_field_name}'
camel_key = f'{camel_formset_name}-{i}-{to_camel_case(snake_field_name)}'
value = data.getlist(camel_key)
_set_list_if_nonempty(snake_cased_data, snake_key, value)
return snake_cased_data
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict(str('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'])
if not six.PY3:
self.assertEqual(q.has_key('vote'), True)
self.assertEqual('vote' in q, True)
if not six.PY3:
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(list(six.iteritems(q)), [('vote', 'no')])
self.assertEqual(list(six.iterlists(q)), [('vote', ['yes', 'no'])])
self.assertEqual(list(six.iterkeys(q)), ['vote'])
self.assertEqual(list(six.itervalues(q)), ['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 handle_cheque_id(request, cheque_id):
if request.method == 'GET':
sql = "SELECT * from cusAccount, chequeAccount WHERE " + \
"cusA_accountIDX = accountIDX and accountIDX = %s"
sqlparams = (cheque_id,)
metadata, data = api__REQUEST.query_all(sql, sqlparams)
return db_connect.httpRespOK("OK", metadata, data)
elif request.method == 'PUT': # 更新
put = QueryDict(request.body)
field = put.getlist('field', None)
field_value = put.getlist('field_value', None)
if len(field) != 2:
return db_connect.httpRespError("需要两个参数: 操作对应的 customID 和 更新后余额 remain")
if field[0] != 'cust_customID' or field[1] != 'remain_change':
return db_connect.httpRespError("两个参数依次是 cust_customID 和 remain_change.")
custom_id = field_value[0]
remain_change = float(field_value[1])
api__REQUEST.call_procedure('proc_alter_cheAccount',[cheque_id, custom_id, remain_change])
return db_connect.httpRespOK("OK")
elif request.method == 'DELETE':
api__REQUEST.call_procedure('proc_delete_cheAccount', [cheque_id])
return db_connect.httpRespOK("OK")
elif request.method == 'POST': # 给账户添加用户
api__REQUEST.insert_one('cus_and_cheAccount', {
'cust_customID': request.POST['cust_customID'],
'cheq_cusA_accountIDX': cheque_id})
return db_connect.httpRespOK("OK")
else:
return db_connect.httpRespError("不支持的method.")
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict(str("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"])
if six.PY2:
self.assertEqual(q.has_key("vote"), True)
self.assertEqual("vote" in q, True)
if six.PY2:
self.assertEqual(q.has_key("foo"), False)
self.assertEqual("foo" in q, False)
self.assertEqual(list(six.iteritems(q)), [("vote", "no")])
self.assertEqual(list(six.iterlists(q)), [("vote", ["yes", "no"])])
self.assertEqual(list(six.iterkeys(q)), ["vote"])
self.assertEqual(list(six.itervalues(q)), ["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 __init__(
self,
query: QueryDict,
params: Mapping[Any, Any],
allow_minute_resolution: Optional[bool] = True,
):
raw_fields = query.getlist("field", [])
raw_groupby = query.getlist("groupBy", [])
if len(raw_fields) == 0:
raise InvalidField('At least one "field" is required.')
self.fields = {}
self.query: List[Any] = [] # not used but needed for compat with sessions logic
allowed_resolution = (
AllowedResolution.one_minute if allow_minute_resolution else AllowedResolution.one_hour
)
start, end, rollup = get_constrained_date_range(query, allowed_resolution)
self.dataset, self.match = _outcomes_dataset(rollup)
self.rollup = rollup
self.start = start
self.end = end
self.select_params = []
for key in raw_fields:
if key not in COLUMN_MAP:
raise InvalidField(f'Invalid field: "{key}"')
field = COLUMN_MAP[key]
self.select_params.append(field.select_params(self.dataset))
self.fields[key] = field
self.groupby = []
for key in raw_groupby:
if key not in GROUPBY_MAP:
raise InvalidField(f'Invalid groupBy: "{key}"')
self.groupby.append(GROUPBY_MAP[key])
if len(query.getlist("category", [])) == 0 and "category" not in raw_groupby:
raise InvalidQuery("Query must have category as groupby or filter")
query_columns = set()
for field in self.fields.values():
query_columns.update(field.get_snuba_columns(raw_groupby))
for groupby in self.groupby:
query_columns.update(groupby.get_snuba_columns())
self.query_columns = list(query_columns)
query_groupby = set()
for groupby in self.groupby:
query_groupby.update(groupby.get_snuba_groupby())
self.query_groupby = list(query_groupby)
self.group_by = []
for key in self.query_groupby:
self.group_by.append(Column(key))
self.conditions = self.get_conditions(query, params)
def p_list(request):
## Récup des données ##
p_list = Product.objects.all().order_by("ProductName")
pt_list = ProductType.objects.all().order_by("Type")
pst_list = ProductSubType.objects.all().order_by("SubType")
pb_list = ProductBrand.objects.all().order_by("Name")
#######################
## Search filter ##
q = QueryDict(request.GET.get("q"))
if q.__contains__("q_categorie"):
q_categorie = q.getlist("q_categorie")
p_list = Product.objects.filter(
reduce(lambda x, y: x | y,
[Q(ProductType__Type=item) for item in q_categorie]))
if q.__contains__("q_subtypeproduct"):
q_subtypeproduct = q.getlist("q_subtypeproduct")
p_list = p_list.filter(
reduce(
lambda x, y: x | y,
[Q(ProductSubType__SubType=item)
for item in q_subtypeproduct]))
if q.__contains__("q_brand"):
q_brand = q.getlist("q_brand")
p_list = p_list.filter(
reduce(lambda x, y: x | y,
[Q(Brand__Name=item) for item in q_brand]))
###################
## Ajout du tri ##
p_list.order_by("ProductName")
# à développer avec tri dynamique
##################
## Gestion de la pagination ##
paginator = Paginator(p_list, 12)
page = request.GET.get('page')
try:
products = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
products = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
products = paginator.page(paginator.num_pages)
##############################
return render(
request, 'backoffice/p_list.html', {
'products': products,
'ptypes': pt_list,
'psubtypes': pst_list,
'pbrands': pb_list,
'cart': Cart(request)
})
def render(self, context):
try:
GET = context.get('request').GET.copy()
except AttributeError:
GET = QueryDict("", mutable=True)
for attr, op, val in self.triples:
actual_attr = attr.resolve(context)
try:
actual_val = val.resolve(context)
except:
if val.var == "None":
actual_val = None
else:
actual_val = val.var
if actual_attr:
if op == "=":
if actual_val is None or actual_val == []:
if GET.has_key(actual_attr):
del GET[actual_attr]
elif hasattr(actual_val, '__iter__'):
GET.setlist(actual_attr, actual_val)
else:
GET[actual_attr] = unicode(actual_val)
elif op == "+=":
if actual_val is None or actual_val == []:
if GET.has_key(actual_attr):
del GET[actual_attr]
elif hasattr(actual_val, '__iter__'):
GET.setlist(
actual_attr,
GET.getlist(actual_attr) + list(actual_val))
else:
GET.appendlist(actual_attr, unicode(actual_val))
elif op == "-=":
li = GET.getlist(actual_attr)
if hasattr(actual_val, '__iter__'):
for v in list(actual_val):
if v in li:
li.remove(v)
GET.setlist(actual_attr, li)
else:
actual_val = unicode(actual_val)
if actual_val in li:
li.remove(actual_val)
GET.setlist(actual_attr, li)
return fix_ampersands(GET.urlencode())
def search_url(context, facet='', term='', remove=False, absolute=True):
"""
Generate search url starting from action-list defined url.
If absolute is True (as default) this tag remove all other facets,
to returns only the provided one (facet:term).
Else replace or append provided facet:term.
If remove is True this tag remove only provided facet:term.
"""
if 'search_using' in context:
if context['search_using'].startswith('initiative'):
url = reverse('projects:initiative-search')
else:
url = reverse('projects:project-search')
else:
# back-compatibility
url = reverse('projects:project-search')
if not facet:
return url
if not term:
if absolute:
return u"{0}?q={1}".format(url, facet)
else:
query = context['request'].GET.copy()
query['q'] = facet
return u"{0}?{1}".format(url, query.urlencode(safe=':/'))
value = u"{0}:{1}".format(facet, term)
if absolute:
query = QueryDict('', mutable=True)
query.update({'selected_facets': value})
return u"{0}?{1}".format(url, query.urlencode(safe=':/'))
query = context['request'].GET.copy()
if remove:
if value in query.getlist('selected_facets'):
query.setlist(
'selected_facets',
filter(lambda x: x != value, query.getlist('selected_facets')))
else:
if value not in query.getlist('selected_facets'):
query.appendlist('selected_facets', value)
# remove page from query to avoid empty pages
if 'page' in query:
del query['page']
return u"{0}?{1}".format(url, query.urlencode(safe=':/'))
def adminEvent(request):
try:
name = request.session["name"]
if (request.method == "POST"):
try:
names = request.POST["delete"]
names = names.split("-")
for name in names:
try:
eve = EventCreator.objects.get(eventName=name)
mem = EventMember.objects.filter(eventName=name)
eve.delete()
mem.delete()
except Exception as e:
pass
except Exception as e:
try:
string = request.POST["top3"]
dict = QueryDict(string)
print(dict)
regs = dict.getlist("regno")
scores = dict.getlist("score")
Topscores.objects.all().delete()
for i in range(len(regs)):
try:
member = Member.objects.get(regno=regs[i].upper())
print(member)
ts = Topscores.objects.get_or_create(member=member)
ts[0].score = scores[i]
ts[0].save()
except Exception as e:
pass
except Exception:
name = request.POST["name"]
description = request.POST["description"]
number = request.POST["number"]
try:
eve = EventCreator.objects.get_or_create(
eventName=name,
description=description,
team=number)
except Exception:
pass
events = EventCreator.objects.all()
return render(request, 'Administrator/adminEvent.html',
{'events': events})
except Exception:
return redirect('administrator')
def render(self, context):
try:
GET = context.get('request').GET.copy()
except AttributeError:
GET = QueryDict("", mutable=True)
for attr, op, val in self.triples:
actual_attr = attr.resolve(context)
try:
actual_val = val.resolve(context)
except:
if val.var == "None":
actual_val = None
else:
actual_val = val.var
if actual_attr:
if op == "=":
if actual_val is None or actual_val == []:
if GET.has_key(actual_attr):
del GET[actual_attr]
elif hasattr(actual_val, '__iter__'):
GET.setlist(actual_attr, actual_val)
else:
GET[actual_attr] = unicode(actual_val)
elif op == "+=":
if actual_val is None or actual_val == []:
if GET.has_key(actual_attr):
del GET[actual_attr]
elif hasattr(actual_val, '__iter__'):
GET.setlist(actual_attr, GET.getlist(actual_attr) + list(actual_val))
else:
GET.appendlist(actual_attr, unicode(actual_val))
elif op == "-=":
li = GET.getlist(actual_attr)
if hasattr(actual_val, '__iter__'):
for v in list(actual_val):
if v in li:
li.remove(v)
GET.setlist(actual_attr, li)
else:
actual_val = unicode(actual_val)
if actual_val in li:
li.remove(actual_val)
GET.setlist(actual_attr, li)
return fix_ampersands(GET.urlencode())
def get_estimate_risk_form(request):
covid = Disease.objects.get(icd_10_code='U07.1')
comorbid_list = ComorbidConditionCfr.objects.filter(disease=covid)
comorbid_names = list()
for comorbid in comorbid_list:
comorbid_names.append((comorbid.comorbid_disease.disease_id, comorbid.comorbid_disease.name))
if request.method == 'GET':
if len(request.GET['form']) == 0:
form = EstimateRisksForm()
form.fields['comorbid'].choices = comorbid_names
form.fields['social_activity_level'].initial = ('mid')
form.fields['start_date'].initial = datetime.date.today
form.fields['end_date'].initial = datetime.date.today
else:
form_data = QueryDict(request.GET['form'].encode('ASCII'))
form = EstimateRisksForm()
form.fields['country_2_a_code'].initial = request.GET['country_code']
form.fields['comorbid'].choices = comorbid_names
if 'comorbid' in form_data:
form.fields['comorbid'].initial = form_data.getlist('comorbid')
form.fields['start_date'].initial = form_data['start_date']
form.fields['end_date'].initial = form_data['end_date']
form.fields['age'].initial = form_data['age']
form.fields['social_activity_level'].initial = form_data['social_activity_level']
allow_submit = covid_model.check_if_country_code_acceptable(request.GET['country_code'])
return render(request, 'estimate_risks_form.html', context={'form': form,
'allow_submit': allow_submit})
else:
return HttpResponse("Request method is not a GET")
def preserve_filter_parameters(report, querydict):
"""
Given a report and submission, preserve the `next` and `index`
query parameters as these are essential to maintaining the current
filter navigation.
"""
return_url_args = querydict.get('next', '')
next_page = urllib.parse.quote(return_url_args)
index = querydict.get('index', '')
if return_url_args:
querydict = QueryDict(return_url_args)
report_query, _ = report_filter(querydict)
sort = querydict.getlist('sort', ['-create_date'])
requested_query = report_query.order_by(*sort)
requested_ids = list(requested_query.values_list('id', flat=True))
try:
index = requested_ids.index(report.id)
except ValueError:
# rely on the index query param, if any. this will happen
# if changes to the report cause the report to move out of
# the filtered list.
pass
return f'{report.get_absolute_url()}?next={next_page}&index={index}'
def post(self, request, *args, **kwargs):
qdict = QueryDict('', mutable=True)
qdict.update(request.FILES)
files = qdict.getlist("data_file[]")
saved_files = []
zpath = Storage.get_available_name(default_storage, 'Bioimp.zip')
path_zip = os.path.join(settings.MEDIA_ROOT, zpath)
zf = zipfile.ZipFile(path_zip, "w")
p = re.compile(r'(\D),(\D)')
for f in files:
broken_file = p.sub(r'\1;\2', f.read().decode('utf-8'))
repaired_file = pd.read_csv(io.StringIO(broken_file), sep=';')
repaired_file = repaired_file.iloc[:, [0, 1, 2]]
path = Storage.get_available_name(default_storage,
os.path.join('tmp', f.name))
file_name = os.path.join(settings.MEDIA_ROOT, path)
repaired_file.to_csv(file_name, sep=';', index=False)
saved_files.append({
"name": f.name,
"data": repaired_file.values.tolist()
})
zf.write(file_name, os.path.basename(file_name))
os.remove(file_name)
zf.close()
"""tmp_file = os.path.join(settings.MEDIA_ROOT, path)
saved_files.append(tmp_file)
ziped_files = filefixer.repair_csv(saved_files) """
""" qdict = QueryDict('', mutable=True)
qdict.update(request.FILES)
files = qdict.getlist("data_file[]")
saved_files = []
for f in files:
path = default_storage.save(f'tmp/{f}', ContentFile(f.read()))
tmp_file = os.path.join(settings.MEDIA_ROOT, path)
saved_files.append(tmp_file)
ziped_files = filefixer.repair_csv(saved_files) """
responseData = {
'initialPreview': [],
'initialPreviewConfig': [],
'initialPreviewThumbTags': [],
'append': True,
'urlDownload': os.path.basename(zf.filename),
'graphData': saved_files,
}
return JsonResponse(responseData)
def togglecontext(request, context):
"""
Toggles context and returns the resulting url as a string
"""
# parse the original url
parsed_url = urlparse(request.get_full_path())
# create a QueryDict to parse the GET params
queries = QueryDict(parsed_url.query, mutable=True)
# get contexts param
contexts = queries.getlist("context")
if contexts:
if context.slug in contexts:
contexts.remove(context.slug)
else:
contexts.append(context.slug)
if contexts:
queries.setlist("context", contexts)
else:
del queries["context"]
else:
queries["context"] = context.slug
queries = queries.urlencode()
new_url = urlunparse(
(
parsed_url.scheme,
parsed_url.netloc,
parsed_url.path,
parsed_url.params,
queries,
parsed_url.fragment,
)
)
return new_url
def post(self, request):
post_params = QueryDict(request.body)
try:
content = post_params['content']
except Exception:
return Response({
"result":
None,
"error":
"The request could not be processed due to a syntax error."
})
category_ids = post_params.getlist('category_ids', None)
new_request = Requests.objects.create(content=content)
if category_ids:
new_request.is_marked_up = True
try:
new_request.save()
except Exception:
return Response({
"result":
None,
"error":
"The request could not be processed due to a syntax error."
})
for category_id in category_ids:
category = Categories.objects.get(id=category_id)
if category is not None:
category.requests_set.add(new_request)
return AdminRequestSingleView.get(self, request, new_request.pk)
def fix_categorization_docstashes(apps, schema_editor):
DocStash = apps.get_model('docstash', 'DocStash')
stashes = DocStash.objects.filter(
group='ecs.core.views.submissions.categorization')
for stash in stashes:
if 'POST' in stash.value:
post = QueryDict(stash.value['POST'], mutable=True)
post.pop('gcp_review_required', None)
post.pop('insurance_review_required', None)
post.pop('external_reviewers', None)
post.pop('statistical_review_required', None)
post.pop('legal_and_patient_review_required', None)
post.pop('expedited_review_categories', None)
post.pop('executive_comment', None)
if 'workflow_lane' in post and not post['workflow_lane']:
post.pop('workflow_lane')
if post.getlist('medical_categories') in ([], ['']):
post.pop('medical_categories')
if 'remission' in post and post['remission'] == 'False':
post.pop('remission')
if list(post.keys()) == ['csrfmiddlewaretoken']:
stash.delete()
else:
stash.value['POST'] = post.urlencode()
stash.save()
def render(self, context):
base_qs = self.base_qs.resolve(context)
if isinstance(base_qs, QueryDict):
qs = base_qs.copy()
else:
qs = QueryDict(base_qs, mutable=True)
for arg in self.args:
if arg.startswith("delete:"):
v = arg[7:]
if v in qs:
del qs[v]
elif arg.startswith("delete_value:"):
field, value = arg[13:].split(",", 2)
value = template.Variable(value).resolve(context)
f_list = qs.getlist(field)
if value in f_list:
f_list.remove(value)
qs.setlist(field, f_list)
else:
k, v = arg.split("=", 2)
qs[k] = template.Variable(v).resolve(context)
return escape(qs.urlencode())
def delete(self, request):
ret = {}
ret['status'] = 0
if not request.user.has_perm('user.manager_permission'):
ret['status'] = 1
ret['errmsg'] = u'You not permission'
logger.error(
'user:{} not permission access groupdeluser(delete)'.format(
request.user))
return JsonResponse(ret, safe=True)
data = QueryDict(request.body)
userid = data.getlist('useridlist[]', None)
gid = data.get('gid', None)
try:
group = Group.objects.get(pk=gid)
for i in userid:
user = UserProfile.objects.get(pk=i)
group.user_set.remove(user)
except Group.DoesNotExist:
ret['status'] = 1
ret['errmsg'] = u"The group does not exists!"
except UserProfile.DoesNotExist:
ret['status'] = 1
ret['errmsg'] = u"The user does not exists!"
return JsonResponse(ret, safe=True)
def delete_files(request):
""" Deletes multiple uploaded files. """
logger, user, upload_folder, process_folder = get_user_and_folders_plus_logger(request)
logger.info("Deleting files for user: %s" % user)
data = {}
data['results'] = []
data['success'] = False
del_dict = QueryDict(request.body)
target_fnames = del_dict.getlist('delete_file[]');
file_type = 'upload'
file_folder = os.path.join(settings.FILE_FOLDER_MAP.get(file_type), user)
# Prevent files from being renamed/deleted if the workflow is running
is_workflow_running = process_data.check_workflow_running(user, process_folder)
if not is_workflow_running:
for target_fname in target_fnames:
logger.info("Deleting file %s" % target_fname)
target_file = os.path.join(file_folder, target_fname)
data['results'].append(process_data.delete_file(target_file, target_fname, file_folder, logger))
data['success'] = all([file['success'] for file in data['results']]) if data['results'] else False
else:
data['success'] = False
data['target_files'] = target_fnames;
data['error_msg'] = "Files cannot be deleted when a workflow is running."
return JsonResponse(data)
def put(self, request, pk):
try:
request_object = get_object_or_404(Requests.objects.all(), pk=pk)
except Exception:
return Response({
"result":
None,
"error":
"The request could not be processed due to a syntax error."
})
post_params = QueryDict(request.body)
category_ids = post_params.getlist('category_ids')
if category_ids:
request_object.is_marked_up = True
try:
request_object.save()
except Exception:
return Response({
"result":
None,
"error":
"The request could not be processed due to a syntax error."
})
for category_id in category_ids:
category = Categories.objects.get(id=category_id)
if category is not None:
category.requests_set.add(request_object)
return RequestSingleView.get(self, request, request_object.pk)
def apply_dataset_filters(user, filter_parameters):
"""
Applies the filters on all collections, resources viewable to `user`
for facilitating dataset export.
Returns tuple(QuerySet<Collection>, QuerySet<ResourceContainer>)
"""
filter_query_dict = QueryDict(filter_parameters)
collection_id = filter_query_dict.getlist('collection', None)
# At the moment, dataset can be created either using collection IDs
# or resource filters, but NOT BOTH. You can't have collection IDs
# listed along with resource filter parameters.
if collection_id:
collections = authorization.apply_filter(CollectionAuthorization.VIEW,
user,
Collection.objects.filter(id__in=collection_id,
hidden=False))
containers = ResourceContainer.objects.none()
else:
collections = Collection.objects.none()
containers = authorization.apply_filter(ResourceAuthorization.VIEW,
user,
ResourceContainer.active.all())
containers = ResourceContainerFilter(filter_query_dict,
queryset=containers).qs
return collections, containers
def update_profile_details(request,member_id):
m = get_object_or_404(Member,id=member_id)
if request.method == "PUT":
try:
put = QueryDict(request.body)
fname = put.get('updatefirstname')
lname = put.get('updatelastname')
gender = put.get('updategender')
hobby = put.getlist('updatehobby[]')
if len(hobby)==0:
return JsonResponse({"success":False})
if fname == "":
return JsonResponse({"success":False})
if lname == "":
return JsonResponse({"success":False})
m.firstName = fname
m.lastName = lname
m.gender = gender
for hobbyVal in hobby:
print(hobbyVal)
hob = Hobby.objects.filter(hobby=hobbyVal)
m.hobbies.add(hob[0])
m.save()
except Member.DoesNotExist:
return JsonResponse({"success":False})
return JsonResponse({"success":True})
def handle_id(request:HttpRequest, customer_id):
# 处理GET
if request.method == 'GET': # 获取一个客户信息
metadata, data = api__REQUEST.specify_get([], 'customer', 'customID', customer_id)
return db_connect.httpRespOK("OK", metadata, data)
elif request.method == 'PUT': # 更新一个客户信息
put = QueryDict(request.body)
field = put.getlist('field',None)
field_value = put.getlist('field_value',None)
api__REQUEST.specify_update('customer', field, field_value, 'customID', customer_id)
return db_connect.httpRespOK("OK")
elif request.method == 'DELETE': # 删除一个客户信息
api__REQUEST.specify_delete('customer', 'customID', customer_id)
return db_connect.httpRespOK("OK")
else:
return db_connect.httpRespError()
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 add_asset_api(request):
new_asset_args = QueryDict(request.body)
tags = new_asset_args.getlist('tags')
new_asset_args_dict = QueryDict(request.body).dict()
new_asset_args_dict.update({"owner": request.user})
new_asset_args_dict.pop("tags", None)
try:
asset = Asset(**new_asset_args_dict)
asset.save()
# Add categories
for cat in tags:
c = AssetCategory.objects.filter(value=cat).first()
if c:
asset.categories.add(c)
asset.save()
return JsonResponse(asset.to_dict())
except Exception:
return JsonResponse({
'status':
'error',
'reason':
'Unable to create asset with provided args.'
})
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(), [(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 get_queryset(self):
if self.request.method == "DELETE":
qdict = QueryDict("", mutable=True)
qdict.update(self.request.data)
list_ = qdict.getlist("pk")
return PrivateTopic.objects.get_private_topics_selected(self.request.user.id, list_)
return PrivateTopic.objects.get_private_topics_of_user(self.request.user.id)
def populate(self, data: QueryDict):
prod_pks = data.getlist('pl_product')
prod_pks = [k for k in prod_pks if k]
if prod_pks:
qs = Product.objects.filter(pk__in=prod_pks)
self.fields['pl_product'].queryset = qs
comp_pks = data.getlist('pl_component')
comp_pks = [k for k in comp_pks if k]
if comp_pks:
qs = Component.objects.filter(pk__in=comp_pks)
self.fields['pl_component'].queryset = qs
ver_pks = data.getlist('pl_version')
ver_pks = [k for k in ver_pks if k]
if ver_pks:
qs = Version.objects.filter(pk__in=ver_pks)
self.fields['pl_version'].queryset = qs
def populate(self, data: QueryDict):
prod_pks = data.getlist('r_product')
prod_pks = [k for k in prod_pks if k]
if prod_pks:
qs = Product.objects.filter(pk__in=prod_pks).only('name')
self.fields['r_product'].queryset = qs
build_pks = data.getlist('r_build')
build_pks = [k for k in build_pks if k]
if build_pks:
qs = TestBuild.objects.filter(pk__in=build_pks).only('name')
self.fields['r_build'].queryset = qs
ver_pks = data.getlist('r_version')
ver_pks = [k for k in ver_pks if k]
if ver_pks:
qs = Version.objects.filter(pk__in=ver_pks).only('value')
self.fields['r_version'].queryset = qs
def get_queryset(self):
if self.request.method == 'DELETE':
qdict = QueryDict('', mutable=True)
qdict.update(self.request.data)
list_ = qdict.getlist('pk')
return PrivateTopic.objects.get_private_topics_selected(self.request.user.id, list_)
return PrivateTopic.objects.get_private_topics_of_user(self.request.user.id)
def normalize_search_querydict(qd: QueryDict):
search = qd.get('search', '')
field_names_lookup = PublicationDocSearch.get_filter_field_names()
filters = {}
for field_name in field_names_lookup:
filters[field_name] = set(int(ident) for ident in qd.getlist(field_name))
return search, filters
def test_invalid_input_encoding(self):
"""
QueryDicts must be able to handle invalid input encoding (in this
case, bad UTF-8 encoding).
"""
q = QueryDict('foo=bar&foo=\xff')
self.assertEqual(q['foo'], u'\ufffd')
self.assertEqual(q.getlist('foo'), [u'bar', u'\ufffd'])
def test_invalid_input_encoding(self):
"""
QueryDicts must be able to handle invalid input encoding (in this
case, bad UTF-8 encoding).
"""
q = QueryDict("foo=bar&foo=\xff")
self.assertEqual(q["foo"], u"\ufffd")
self.assertEqual(q.getlist("foo"), [u"bar", u"\ufffd"])
def filter_preprocessor_params(post: QueryDict, filtered_params={}):
prefix = post['apply_preprocessor_preprocessor_key']
for param in post:
if param.startswith(prefix):
filtered_params[param] = post.getlist(param)
return filtered_params
def filter_preprocessor_params(post: QueryDict, filtered_params={}):
prefix = post['apply_preprocessor_preprocessor_key']
for param in post:
if param.startswith(prefix):
filtered_params[param] = post.getlist(param)
return filtered_params
def test_invalid_input_encoding(self):
"""
QueryDicts must be able to handle invalid input encoding (in this
case, bad UTF-8 encoding).
"""
q = QueryDict('foo=bar&foo=\xff')
self.assertEqual(q['foo'], u'\ufffd')
self.assertEqual(q.getlist('foo'), [u'bar', u'\ufffd'])
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict(str('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'])
if six.PY2:
self.assertIs(q.has_key('vote'), True)
self.assertIn('vote', q)
if six.PY2:
self.assertIs(q.has_key('foo'), False)
self.assertNotIn('foo', q)
self.assertEqual(list(six.iteritems(q)), [('vote', 'no')])
self.assertEqual(list(six.iterlists(q)), [('vote', ['yes', 'no'])])
self.assertEqual(list(six.iterkeys(q)), ['vote'])
self.assertEqual(list(six.itervalues(q)), ['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_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_invalid_input_encoding(self):
"""
QueryDicts must be able to handle invalid input encoding (in this
case, bad UTF-8 encoding).
This test doesn't apply under Python 3 because the URL is a string
and not a bytestring.
"""
q = QueryDict(str(b'foo=bar&foo=\xff'))
self.assertEqual(q['foo'], '\ufffd')
self.assertEqual(q.getlist('foo'), ['bar', '\ufffd'])
def test_invalid_input_encoding(self):
"""
QueryDicts must be able to handle invalid input encoding (in this
case, bad UTF-8 encoding), falling back to ISO-8859-1 decoding.
This test doesn't apply under Python 3 because the URL is a string
and not a bytestring.
"""
q = QueryDict(str(b"foo=bar&foo=\xff"))
self.assertEqual(q["foo"], "\xff")
self.assertEqual(q.getlist("foo"), ["bar", "\xff"])
def test_immutable_basic_operations(self):
q = QueryDict()
self.assertEqual(q.getlist('foo'), [])
if six.PY2:
self.assertIs(q.has_key('foo'), False)
self.assertNotIn('foo', q)
self.assertEqual(list(six.iteritems(q)), [])
self.assertEqual(list(six.iterlists(q)), [])
self.assertEqual(list(six.iterkeys(q)), [])
self.assertEqual(list(six.itervalues(q)), [])
self.assertEqual(len(q), 0)
self.assertEqual(q.urlencode(), '')
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 test_immutable_basic_operations(self):
q = QueryDict(str(''))
self.assertEqual(q.getlist('foo'), [])
if not six.PY3:
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(list(six.iteritems(q)), [])
self.assertEqual(list(six.iterlists(q)), [])
self.assertEqual(list(six.iterkeys(q)), [])
self.assertEqual(list(six.itervalues(q)), [])
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 get_photo_queryset(album=None, query=None, person=None):
if album:
return album.photo_set.all()
if person:
return person.photo_set.all()
if query:
query_dict = QueryDict(query)
queryset = Photo.objects.all()
q = query_dict.get('q')
if q:
queryset = queryset.filter(
Q(name__icontains=q) | Q(album__name__icontains=q))
a = query_dict.getlist('a')
if a:
queryset = queryset.filter(album__in=a)
p = query_dict.getlist('p')
if p:
queryset = queryset.filter(people__in=p)
l = query_dict.getlist('l')
if l:
queryset = queryset.filter(album__location__in=l)
return queryset
def get_search_queryset(query):
"""
Build and return a Photo queryset based on the parameters passed in, which will be a querystring
containing the user's search terms.
"""
data = QueryDict(query)
queryset = Photo.objects.all()
q = data.get('q')
a = data.getlist('a')
p = data.getlist('p')
l = data.getlist('l')
if q:
queryset = queryset.filter(Q(name__icontains=q) | Q(album__name__icontains=q))
if a:
queryset = queryset.filter(album__in=a)
if p:
queryset = queryset.filter(people__in=p)
if l:
queryset = queryset.filter(album__location__in=l)
return queryset
def search_lbl(request):
if request.POST:
# translate the query string into a dictionary:
# e.g. 'numin=0.&numax=100.&...' -> {'numin': 0., 'numax': 100., ...}
q = QueryDict(request.POST['post_data'])
numin = q.get('numin')
if numin: numin=float(numin)
numax = q.get('numax')
if numax: numax=float(numax)
Smin = q.get('Smin')
if Smin: Smin=float(Smin)
# The form returns molecule=<molecID> for any checked
# <molec_name> boxes:
selected_molecids = q.getlist('molecule')
selected_molecules = Molecules.objects.filter(
molecid__in=selected_molecids).values(
'molec_name','molec_name_html')
# here's where the real work is done:
start = time.time()
req = make_request(numin, numax, Smin, selected_molecids,
output_params = None,
output_formats = 'par',
compression = None)
HITRAN.read_db_from_mysql(req,'christian','whatever')
finish = time.time()
return HttpResponse('Hello Sir!')
# make the HTML for the molecule checkboxes:
molec_cb_html_soup = ['<table>\n']
i = 0
for molecule in molecules:
if not i % 4: molec_cb_html_soup.append('<tr>')
molec_cb_html_soup.append('<td><input type="checkbox"' \
' name="molecule" value="%d"/> %s</td>'
% (molecule['molecid'], molecule['molec_name_html']))
if i%4 == 3: molec_cb_html_soup.append('</tr>\n')
i += 1
molec_cb_html_soup.append('</table>\n')
molec_cb_html = ''.join(molec_cb_html_soup)
selected_output_fields = ['nu','S']
available_output_fields = ['A','g_air','g_self','n_air',
'delta_air','QN-upper','QN-lower']
return render_to_response('search_lbl.html',
{'molec_cb_html': molec_cb_html,
'available_output_fields': available_output_fields,
'selected_output_fields': selected_output_fields})
def put(self, request, name):
self.check_login()
if request.user.username != name:
self.raise_error('Permission denied.', status=403)
# Django doesn't parse request body in PUT request
# See: http://stackoverflow.com/a/22294734
params = QueryDict(request.body)
ids = params.getlist('ids[]')
category_ids = [c.id for c in request.user.category_set.all()]
if len(ids) != len(category_ids) and \
set(ids) != set(category_ids):
self.raise_error(u'분류 정보가 최신이 아닙니다. 새로고침 후 다시 시도해주세요.',
status=409) # 409 Conflict
for position, id in enumerate(ids):
request.user.category_set.filter(id=int(id)) \
.update(position=position)
return map(serialize_category, request.user.category_set.all())
def test_single_key_value(self):
"""Test QueryDict with one key/value pair"""
q = QueryDict(str("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"])
if six.PY2:
self.assertTrue(q.has_key("foo"))
self.assertIn("foo", q)
if six.PY2:
self.assertFalse(q.has_key("bar"))
self.assertNotIn("bar", q)
self.assertEqual(list(six.iteritems(q)), [("foo", "bar")])
self.assertEqual(list(six.iterlists(q)), [("foo", ["bar"])])
self.assertEqual(list(six.iterkeys(q)), ["foo"])
self.assertEqual(list(six.itervalues(q)), ["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(str('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'])
if six.PY2:
self.assertTrue(q.has_key('foo'))
self.assertIn('foo', q)
if six.PY2:
self.assertFalse(q.has_key('bar'))
self.assertNotIn('bar', q)
self.assertEqual(list(six.iteritems(q)), [('foo', 'bar')])
self.assertEqual(list(six.iterlists(q)), [('foo', ['bar'])])
self.assertEqual(list(six.iterkeys(q)), ['foo'])
self.assertEqual(list(six.itervalues(q)), ['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 modify_urlquery(in_url, **kwargs):
"""Modify the query part of a URL.
Supplying delete=True will remove all matching parameters matching the value.
"""
safe = kwargs.pop('safe', None)
delete = kwargs.pop('delete', False)
scheme, netloc, path, query, fragment = urlsplit(in_url)
q_dict = QueryDict(query, mutable=True)
for k, v in kwargs.items():
param_list = q_dict.getlist(k)
if delete:
q_dict.setlist(k, [x for x in param_list if x != v])
else:
if v not in param_list:
q_dict.appendlist(k, v)
return urlunsplit((scheme, netloc, path, q_dict.urlencode(safe=safe), fragment))
def index(request):
if request.method == 'POST':
players = QueryDict(request.POST['content'])
for index, player_id in enumerate(players.getlist('player[]')):
player = Player.objects.get(id=player_id)
player.rank = index
player.save()
qb_list = Player.objects.filter(position="QB")
rb_list = Player.objects.filter(position="RB")
wr_list = Player.objects.filter(position="WR")
te_list = Player.objects.filter(position="TE")
def_list = Player.objects.filter(position="DST")
k_list = Player.objects.filter(position="K")
context = {'qb_list': qb_list, 'rb_list': rb_list, 'wr_list': wr_list, 'te_list': te_list, 'def_list': def_list, 'k_list': k_list}
return render_to_response('index.html', context, context_instance=RequestContext(request))
