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 __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 _url_getvars(context, token_=None, type_=None):
assert type_ in (None, 'with', 'without')
request_get = getattr(context.get('request'), 'GET', QueryDict(''))
token, l, r = _url_get_amps(token_)
gv = ''
if type_:
w, wo = type_ == 'with', type_ == 'without'
if w or wo:
lst = [p.strip() for p in token.split(',') if p.strip()]
if w and not lst:
pass
elif wo and not lst:
type_ = None
else:
params = QueryDict('', mutable=True)
if w:
q = lambda x: x
else:
q = lambda x: not x
for key in request_get:
if q(key in lst):
params.setlist(key, request_get.getlist(key))
gv = params.urlencode()
if not type_:
gv = request_get.urlencode()
if gv:
gv = l + gv + r
return gv
def render(self, context):
args, take_from, set_in_context = self.args, self.take_from, self.set_in_context
if take_from is not None:
try:
source = QueryDict(take_from.resolve(context), mutable=True)
except VariableDoesNotExist:
return ''
elif 'request' in context:
request = context['request']
source = request.GET.copy()
else:
return ''
try:
args = [arg.resolve(context) if isinstance(arg, Variable) else arg for arg in args]
except VariableDoesNotExist:
return ''
if args:
source.setlist(args[0], args[1:])
query_string = source.urlencode()
if set_in_context is not None:
context[set_in_context] = query_string
return ''
return query_string
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 index(request):
if request.method == 'POST':
form = MirageForm(request.POST)
if form.is_valid():
paths = form.cleaned_data.get('paths', '').split('\n')
paths = [ path.strip() for path in paths ] # trim whitespace
paths = [ path for path in paths if path ] # skip empty
q = QueryDict('').copy()
q.setlist('path', paths)
query = q.urlencode()
if query: query = "?" + query
servers = form.cleaned_data['servers']
cookie = []
n = len(servers)
for i in range(n):
scope = [ "%s/mirage/%dof%d%s" % \
(settings.MIRAGE_DATARETRIEVER, i+1, n, query) ]
cookie.append(generate_cookie_django(scope, (servers[i],),
blaster=getattr(settings, 'MIRAGE_BLASTER', None)))
return HttpResponse(''.join(cookie),
mimetype='application/x-diamond-scope')
else:
form = MirageForm()
return render_response(request, 'scopeserver/simple_form.html', {
'form': form,
})
def get(self, request):
data = {}
form = self.form_class()
has_valid_columns = any([True for c in request.GET.getlist('columns',[]) if c != ''])
if request.method == 'GET' and has_valid_columns:
# create a form instance and populate it with data from the request:
form = self.form_class(request.GET)
# check whether it's valid:
if form.is_valid():
# process the data in form.cleaned_data as required
filters = form.cleaned_data.get('filter_by',[])
order_by = form.cleaned_data.get('sort_by',[])
columns = form.cleaned_data.get('columns',[])
suspect = form.cleaned_data['lead_suspect']
if hasattr(request, 'user') and request.user.is_staff and request.GET.get('action','') == 'makestatic':
# populate the appropriate GET variables and redirect to the admin site
base = reverse("admin:data_interrogator_datatable_add")
vals = QueryDict('', mutable=True)
vals.setlist('columns',columns)
vals.setlist('filters',filters)
vals.setlist('orders',order_by)
vals['base_model'] = suspect
return redirect('%s?%s'%(base,vals.urlencode()))
else:
data = self.interrogator(suspect,columns=columns,filters=filters,order_by=order_by).interrogate()
# suspects = self.get_model(suspect)
# data = interrogate(suspects,columns=columns,filters=filters,order_by=order_by)
data['form']=form
return render(request, self.template_name, data)
def get_form_kwargs(self):
"""
Get the kwargs to pass to the form for this script. By default, returns the task
arguments.
- 'data' list entries converted into a querydict.
- 'files' list entries converted to File objects
"""
kwargs = self.task.arguments.copy() # don't modify self.task.arguments['data']
if 'data' in kwargs:
d = QueryDict('').copy()
for k, v in kwargs['data'].iteritems():
if isinstance(v, list):
d.setlist(k, v)
else:
d[k] = v
kwargs['data'] = d
# Convert file dictionaries (as supplied by get_temporary_file_dict) to
# SimpleUploadedFile objects which Django understands.
if 'files' in kwargs:
files = MultiValueDict(kwargs['files'])
for filedict_list in files.viewvalues():
for i, fdict in enumerate(filedict_list):
if isinstance(fdict, dict):
fdict = dict(fdict)
fdict["content"] = open(fdict["path"], "rb").read()
filedict_list[i] = SimpleUploadedFile.from_dict(fdict)
kwargs['files'] = files
return kwargs
def pass_on_params(request):
"""
Retrieve the standard filtering parameters from the request and prepare them
as an outgoing URL string so as to preserve session state.
Always get the GET parameters and ignore the POST, because by definition
the query state is in url parameters, which are in GET. Even if POST has
something like tags, they relate to a specific task, not to the query state
TODO: SECURITY is this sufficiently sanitized?
Listing them all individually instead of using **kwargs (I think) because
1) I'm afraid to get into **kwargs black magic
2) Maybe not all parameters should get passed
"""
state_params = QueryDict(query_string=None, mutable=True)
state_params.setlist('tags', request.GET.getlist('tags'))
state_params.setlist('exclude_tags', request.GET.getlist('exclude_tags', ''))
state_params.__setitem__('show_closed', request.GET.get('show_closed', ''))
state_params.__setitem__('show_snoozed', request.GET.get('show_snoozed', ''))
state_params.__setitem__('text_filter', request.GET.get('text_filter', ''))
state_params.__setitem__('page', request.GET.get('page', ''))
return state_params.urlencode()
def get_QueryDict(self, params):
query_dict = QueryDict('', mutable=True)
for k, v in params.items():
if isinstance(v, list):
query_dict.setlist(k, v)
else:
query_dict[k] = v
return query_dict
def _get_filter_params(self):
filter_params = QueryDict('').copy()
for k in self.request.GET.keys():
if self.filter_key(k) in self._filter_keys:
filter_params.setlist(k, self.request.GET.getlist(k))
return filter_params.urlencode()
def clean_filter_query_string(request):
whitelist = QueryDict(mutable=True)
if request.GET:
for key in request.GET.keys():
whitelist.setlist(key, request.GET.getlist(key))
return whitelist
def to_querydict(dict):
"""
Converts a value created by querydict_dict back into a Django QueryDict value.
"""
q = QueryDict("", mutable=True)
for k, v in dict.iteritems():
q.setlist(k, v)
q._mutable = False
return q
def to_querydict(dict):
"""
Converts a value created by querydict_dict back into a Django QueryDict value.
"""
q = QueryDict("", mutable=True)
for k, v in dict.items():
q.setlist(k, v)
q._mutable = False
return q
def test_multiple_params(self):
request = QueryDict('', mutable=True)
request.setlist('param', ['one', 'two'])
paginator = Paginator(request, self.data_set, resource_uri='/api/v1/notes/', limit=2, offset=2)
meta = paginator.page()['meta']
self.assertEqual(meta['limit'], 2)
self.assertEqual(meta['offset'], 2)
self.assertEqual(meta['previous'], '/api/v1/notes/?limit=2¶m=one¶m=two&offset=0')
self.assertEqual(meta['next'], '/api/v1/notes/?limit=2¶m=one¶m=two&offset=4')
self.assertEqual(meta['total_count'], 6)
def restore_get_request(self, request, **default_values):
cached_value = self.cached_data or default_values
new_get_request = QueryDict(mutable=True)
new_get_request.update({**request.GET.dict()})
for key, value in cached_value.items():
if type(value) == list:
new_get_request.setlist(key, value)
else:
new_get_request[key] = value
return new_get_request
def setUp(self):
super(SectionPluginTest, self).setUp()
# add a Bootstrap Container Plugin
container_model = add_plugin(
self.placeholder,
BootstrapContainerPlugin,
'en',
glossary={'breakpoints': BS3_BREAKPOINT_KEYS})
self.assertIsInstance(container_model, CascadeElement)
container_plugin = container_model.get_plugin_class_instance(
self.admin_site)
self.assertIsInstance(container_plugin, BootstrapContainerPlugin)
ModelForm = container_plugin.get_form(self.request, container_model)
post_data = QueryDict('', mutable=True)
post_data.setlist('breakpoints', ['sm', 'md'])
form = ModelForm(post_data, None, instance=container_model)
html = form.as_p()
self.assertInHTML(
'<input id="id_glossary_breakpoints_0" name="breakpoints" type="checkbox" value="xs" />',
html)
self.assertInHTML(
'<input checked="checked" id="id_glossary_breakpoints_2" name="breakpoints" type="checkbox" value="md" />',
html)
self.assertInHTML(
'<input id="id_glossary_fluid" name="fluid" type="checkbox" />',
html)
container_plugin.save_model(self.request, container_model, form, False)
self.assertListEqual(container_model.glossary['breakpoints'],
['sm', 'md'])
self.assertTrue('fluid' in container_model.glossary)
self.assertEqual(str(container_model), 'for tablets, laptops')
# add a RowPlugin with 1 ColumnPlugin
row_model = add_plugin(self.placeholder,
BootstrapRowPlugin,
'en',
target=container_model)
row_plugin = row_model.get_plugin_class_instance()
row_change_form = BootstrapRowForm({'num_children': 1})
row_change_form.full_clean()
row_plugin.save_model(self.request, row_model, row_change_form, False)
self.assertDictEqual(row_model.glossary, {})
self.assertIsInstance(row_model, CascadeElement)
column_models = CascadeElement.objects.filter(parent_id=row_model.id)
self.assertEqual(column_models.count(), 1)
# work with the ColumnPlugin
self.column_model = column_models.first()
self.assertIsInstance(self.column_model, CascadeElement)
self.column_plugin = self.column_model.get_plugin_class_instance()
self.assertIsInstance(self.column_plugin, BootstrapColumnPlugin)
self.assertEqual(self.column_model.parent.id, row_model.id)
self.plugin_list = [container_model, row_model, self.column_model]
def get_form_for_keyword_data(self, keywords):
stall = factories.StallFactory()
data = dict(get_valid_form_data(stall))
querystring = urllib.urlencode(data)
querydict = QueryDict(querystring).copy() #copy so it's mutable
querydict.setlist("keywords_field", keywords)
mock_request = mock.Mock()
mock_request.POST = querydict
return ProductCreationForm(querydict,
request=mock_request,
stall=stall)
def build_url(*args, **kwargs):
params = kwargs.pop('params', {})
url = reverse(*args, **kwargs)
if not params: return url
qdict = QueryDict('', mutable=True)
for k, v in params.iteritems():
if type(v) is list: qdict.setlist(k, v)
else: qdict[k] = v
return url + '?' + qdict.urlencode()
def clean_filter_query_string(request):
whitelist = QueryDict(mutable=True)
has_allowed_param = any(key in request.GET
for key in FILTER_VARIABLE_NAMES)
if request.GET and has_allowed_param:
for key in request.GET.keys():
if key in FILTER_VARIABLE_NAMES:
whitelist.setlist(key, request.GET.getlist(key))
return whitelist
def build_query(**kwargs):
"""Build a query string"""
query_dict = QueryDict(mutable=True)
for k, v in kwargs.items():
if isinstance(v, collections.Iterable) and not isinstance(v, str):
query_dict.setlist(k, v)
else:
query_dict[k] = v
return query_dict.urlencode()
def build_url(*args, **kwargs):
params = kwargs.pop('params', {})
url = reverse(*args, **kwargs)
if not params: return url
qdict = QueryDict('', mutable=True)
for k, v in params.iteritems():
if type(v) is list: qdict.setlist(k, v)
else: qdict[k] = v
return url + '?' + qdict.urlencode()
def build_query(**kwargs):
"""Build a query string"""
query_dict = QueryDict(mutable=True)
for k, v in kwargs.items():
if isinstance(v, collections.Iterable) and not isinstance(v, six.string_types):
query_dict.setlist(k, v)
else:
query_dict[k] = v
return query_dict.urlencode()
def get_query_dict(_dict):
"""
Create QueryDict object from the given dict.
"""
q = QueryDict(mutable=True)
for key, value in _dict.items():
if isinstance(value, (list, set)):
q.setlist(key, value)
else:
q[key] = value
return q
def test_valid_form(self):
query = QueryDict('')
query = query.copy()
in_data = copy.deepcopy(self.valid_data)
select_multi = in_data.pop('select_multi')
check_multi = in_data.pop('check_multi')
query.update(in_data)
query.setlist('select_multi', select_multi)
query.setlist('check_multi', check_multi)
bound_form = DummyForm(data=query)
self.assertTrue(bound_form.is_bound)
self.assertTrue(bound_form.is_valid())
def cleaned_data_querydict(self):
"""
Creates an immutable QueryDict instance from the form's cleaned_data
"""
query = QueryDict('', mutable=True)
# make sure cleaned_data is available, if possible ...
self.is_valid()
cleaned_data = getattr(self, 'cleaned_data', {})
for key, values in cleaned_data.items():
query.setlist(key=key, list_=values)
query._mutable = False
return query
def test_user_mappings_with_query_params_multi_value_key(
self, query_params, expect_code, expect_data):
""" test queries like username=user1&username=user2&... """
base_url = reverse('third_party_auth_user_mapping_api',
kwargs={'provider_id': PROVIDER_ID_TESTSHIB})
params = QueryDict('', mutable=True)
for attr in ['username', 'remote_id']:
if attr in query_params:
params.setlist(attr, query_params[attr])
url = "{}?{}".format(base_url, params.urlencode())
response = self.client.get(url, HTTP_X_EDX_API_KEY=VALID_API_KEY)
self._verify_response(response, expect_code, expect_data)
def parse(query_params, request):
if get_style(request) == 'camelcase':
q = QueryDict('', mutable=True, encoding=query_params.encoding)
for k, l in query_params.lists():
q.setlist(
to_snake_case(k), k != ORDERING_PARAM and l
or list(map(to_snake_case, l)))
q._mutable = False
return q
else:
return query_params
def test_user_mappings_with_query_params_multi_value_key(self, query_params, expect_code, expect_data):
""" test queries like username=user1&username=user2&... """
base_url = reverse(
'third_party_auth_user_mapping_api', kwargs={'provider_id': PROVIDER_ID_TESTSHIB}
)
params = QueryDict('', mutable=True)
for attr in ['username', 'remote_id']:
if attr in query_params:
params.setlist(attr, query_params[attr])
url = "{}?{}".format(base_url, params.urlencode())
response = self.client.get(url, HTTP_X_EDX_API_KEY=VALID_API_KEY)
self._verify_response(response, expect_code, expect_data)
def cleaned_data_querydict(self):
"""
Creates an immutable QueryDict instance from the form's cleaned_data
"""
query = QueryDict("", mutable=True)
# make sure cleaned_data is available, if possible ...
self.is_valid()
cleaned_data = getattr(self, "cleaned_data", {})
for key, values in cleaned_data.items():
query.setlist(key=key, list_=values)
query._mutable = False
return query
def clean(self):
"""Creates the query_string from Filter parameters in the form"""
cleaned_data = super(ExpectationForm, self).clean()
qd = QueryDict(self.cleaned_data["query_string"], mutable=True)
params = ["application__in",
"server_ip__in",
"severity__in",
"search"]
for param in params:
qd.setlist(param, cleaned_data[param])
self.cleaned_data["query_string"] = qd.urlencode()
return cleaned_data
def get_query_string_with_page_number(filter_data, page_number):
qd = QueryDict().copy()
for k, v in filter_data.items():
if not v:
continue
if isinstance(v, list):
qd.setlist(k, v)
else:
qd.update({k, v})
qd.update({'page': page_number})
return qd.urlencode()
def dict_to_querydict(dict_):
"""
Converts a dict value into the Django's QueryDict object.
"""
query_dict = QueryDict('', mutable=True)
for name, value in dict_.items():
if isinstance(name, list):
query_dict.setlist(name, value)
else:
query_dict.appendlist(name, value)
query_dict._mutable = False
return query_dict
def get_request_filters(request):
if request.method == 'GET':
return HaystackFilter.get_request_filters(request)
request_filters = QueryDict(mutable=True)
for param, value in request.data.items():
if isinstance(value, list):
request_filters.setlist(param, value)
else:
request_filters[param] = value
return request_filters
def test_valid_form(self):
query = QueryDict('')
query = query.copy()
in_data = copy.deepcopy(self.valid_data)
select_multi = in_data.pop('select_multi')
check_multi = in_data.pop('check_multi')
query.update(in_data)
query.setlist('select_multi', select_multi)
query.setlist('check_multi', check_multi)
bound_form = DummyForm(data=query)
self.assertTrue(bound_form.is_bound)
self.assertTrue(bound_form.is_valid())
def get_api_url(request, column_index_map, url_name, url_params=None, request_params=None):
"""Returns url with datatables filters"""
data_format = request.GET.get('data_format', '')
if data_format:
params = QueryDict('', mutable=True)
searchable_columns = get_searchable_columns(request, column_index_map, len(column_index_map))
sortable_columns = get_sorted_columns(request, column_index_map)
params.update(request_params or {})
params.update({ 'sSearch': request.GET.get('sSearch', '').encode('utf-8') })
params.setlist('sortable', list(set(sortable_columns)))
params.setlist('searchable', list(set(searchable_columns)))
redirect_url = "?".join([reverse(url_name, kwargs=url_params), params.urlencode()])
return redirect_url
def qdict(d=None):
"""
Convert the given dictionary of lists into a QueryDict, or
return an empty QueryDict if nothing is provided.
"""
qd = QueryDict(mutable=True)
if d is None:
return qd
for key in d:
assert isinstance(d[key], list)
qd.setlist(key, d[key])
return qd
def create_queryUrlStub(query_filtersUrl=None):
""" from the active filters, pre-compose the url so that it can be used in the template more easily where is needed
Returns a string like this : "&filter=2&filter=3&filter=4&filter1=2&filter1=3&filter1=4"
"""
stringa = "filter=0" # initialize
newurl_stub = ""
if query_filtersUrl:
q = QueryDict(stringa).copy()
q.setlist("filter", query_filtersUrl)
newurl_stub = q.urlencode() # eg: 'filter=2&filter=3&filter=4&filter1=2&filter1=3&filter1=4'
newurl_stub = "&" + newurl_stub
# print newurl_stub
return newurl_stub
def run_validation_querydict(self, data=empty):
self._children_set = QueryDict("",
mutable=True,
encoding=data.encoding)
copied = QueryDict("", mutable=True, encoding=data.encoding)
for key, value in data.lists():
if key in self.nested_fields:
self._children_set.setlist(key, value)
else:
copied.setlist(key, value)
data = copied
return super().run_validation(data=data)
def proste_ucilnice_filter(request):
tipi = [
k for k in Ucilnica.OBJAVLJENI_TIPI if request.POST.get(k, '') == 'on'
]
velikosti = [
k for k, v in UcilnicaQuerySet.VELIKOST
if request.POST.get(k, '') == 'on'
]
q = QueryDict(request.POST.get('qstring', ''), mutable=True)
q.setlist('tip', tipi)
q.setlist('velikost', velikosti)
response = redirect('proste')
response['Location'] += "?" + q.urlencode()
return response
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 get(self, request, *args, **kwargs):
# allows us to set defaults on the form
params = QueryDict(mutable=True)
params.update(request.GET)
# initial state
if not params.get('state'):
params.setlist('state', ['open', 'assigned', 'pending_review'])
params.setdefault('format', 'columns')
self.form = TaskFilterForm(self.country, params)
self.form.is_valid()
return super(TaskListView, self).get(request, *args, **kwargs)
def build_url(*args, **kwargs):
params = kwargs.pop('params', {})
url = reverse(*args, **kwargs)
if not params:
return url
qdict = QueryDict('', mutable=True)
for k, v in params.items():
if isinstance(v, list):
qdict.setlist(k, v)
else:
qdict[k] = v
return f'{url}?{qdict.urlencode()}'
def create_queryUrlStub(query_filtersUrl=None):
""" from the active filters, pre-compose the url so that it can be used in the template more easily where is needed
Returns a string like this : "&filter=2&filter=3&filter=4&filter1=2&filter1=3&filter1=4"
"""
stringa = "filter=0" # initialize
newurl_stub = ""
if query_filtersUrl:
q = QueryDict(stringa).copy()
q.setlist('filter', query_filtersUrl)
newurl_stub = q.urlencode(
) # eg: 'filter=2&filter=3&filter=4&filter1=2&filter1=3&filter1=4'
newurl_stub = "&" + newurl_stub
# print newurl_stub
return newurl_stub
def get_form_kwargs(self):
"""
Get the kwargs to pass to the form for this script.
By default, returns the task arguments, with 'data' list entries converted into a querydict
"""
kwargs = self.task.arguments
if 'data' in kwargs:
d = QueryDict('').copy()
for k, v in kwargs['data'].iteritems():
if isinstance(v, list):
d.setlist(k, v)
else:
d[k] = v
kwargs['data'] = d
return kwargs
def parse(self):
post, files = super(MPP, self).parse()
newpost = QueryDict('', mutable=True)
for k, vs in post.iterlists():
if len(vs) == 1 and vs[0].startswith('CoNcOlIc::'):
v = vs[0][len('CoNcOlIc::'):]
ts = v.split(':', 2)
if ts[0] == "concolic_int":
vs = [fuzzy.mk_int(ts[1])]
elif ts[0] == "concolic_str":
vs = [fuzzy.mk_str(ts[1])]
else:
print("UNKNOWN CONCOLIC TYPE %s" % ts[0])
newpost.setlist(k, vs)
return newpost, files
def parse(self):
post, files = super(MPP, self).parse()
newpost = QueryDict('', mutable=True)
for k, vs in post.iterlists():
if len(vs) == 1 and vs[0].startswith('CoNcOlIc::'):
v = vs[0][len('CoNcOlIc::'):]
ts = v.split(':', 2)
if ts[0] == "concolic_int":
vs = [fuzzy.mk_int(ts[1])]
elif ts[0] == "concolic_str":
vs = [fuzzy.mk_str(ts[1])]
else:
print("UNKNOWN CONCOLIC TYPE %s" % ts[0])
newpost.setlist(k, vs)
return newpost, files
def make_pixel_qs(request, job=None):
"""
Constructs a query string that will be appended onto a url pointing at
the My.jobs tracking pixel. This qs should contain all of the information
we want to track about this request.
Inputs:
:request: HttpRequest object for this request
:job: the current job, if this is a job detail page
Returns:
:safe_qs: Encoded, and marked safe query string
"""
current_site = settings.SITE
commitments = current_site.special_commitments.all().values_list('commit',
flat=True)
vs = settings.VIEW_SOURCE
if vs:
vs = vs.view_source
else:
vs = 88
qd = QueryDict('', mutable=True)
qd.setlist('st', settings.SITE_TAGS)
qd.setlist('sc', commitments)
qs = {'d': current_site.domain,
'jvs': vs}
if request.path == '/':
qs['pc'] = 'home'
elif job:
qs['pc'] = 'listing'
qs['jvb'] = job.buid if job.buid else 0
qs['jvg'] = job.guid
qs['jvt'] = job.title_exact
qs['jvc'] = job.company_exact
qs['jvl'] = job.location_exact
try:
company = Company.objects.get(name=job.company_exact)
qs['jvcd'] = company.canonical_microsite
except Company.DoesNotExist:
pass
else:
qs['pc'] = 'results'
qs['sl'] = request.REQUEST.get('location', '')
qs['sq'] = request.REQUEST.get('q', '')
qd.update(qs)
safe_qs = mark_safe(qd.urlencode())
return safe_qs
def test_immutability(self):
q = QueryDict()
with self.assertRaises(AttributeError):
q.__setitem__("something", "bar")
with self.assertRaises(AttributeError):
q.setlist("foo", ["bar"])
with self.assertRaises(AttributeError):
q.appendlist("foo", ["bar"])
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()
def test_immutability(self):
q = QueryDict()
with self.assertRaises(AttributeError):
q.__setitem__('something', 'bar')
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar'])
with self.assertRaises(AttributeError):
q.appendlist('foo', ['bar'])
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()
def test_immutability(self):
q = QueryDict()
with self.assertRaises(AttributeError):
q.__setitem__("something", "bar")
with self.assertRaises(AttributeError):
q.setlist("foo", ["bar"])
with self.assertRaises(AttributeError):
q.appendlist("foo", ["bar"])
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()
def create_query_dict(cls, *args):
queryDict = QueryDict('').copy()
for arg in args:
if isinstance(arg, tuple):
if isinstance(arg[1], list):
# (k, [v1, v2, ..., vn])
queryDict.setlist(arg[0], arg[1])
else:
# (k, v)
queryDict.update({arg[0]: arg[1]})
else:
# { k: v }
queryDict.update(arg)
return queryDict
def test_immutability(self):
q = QueryDict()
with self.assertRaises(AttributeError):
q.__setitem__('something', 'bar')
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar'])
with self.assertRaises(AttributeError):
q.appendlist('foo', ['bar'])
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()
def setUp(self):
super(SectionPluginTest, self).setUp()
# add a Bootstrap Container Plugin
container_model = add_plugin(self.placeholder, BootstrapContainerPlugin, 'en',
glossary={'breakpoints': BS3_BREAKPOINT_KEYS})
self.assertIsInstance(container_model, CascadeElement)
container_plugin = container_model.get_plugin_class_instance(self.admin_site)
self.assertIsInstance(container_plugin, BootstrapContainerPlugin)
ModelForm = container_plugin.get_form(self.request, container_model)
post_data = QueryDict('', mutable=True)
post_data.setlist('breakpoints', ['sm', 'md'])
form = ModelForm(post_data, None, instance=container_model)
soup = BeautifulSoup(form.as_p(), features='lxml')
input_element = soup.find(id="id_glossary_breakpoints_0")
self.assertDictContainsSubset({'type': 'checkbox', 'name': 'breakpoints', 'value': 'xs'},
input_element.attrs)
input_element = soup.find(id="id_glossary_breakpoints_2")
self.assertDictContainsSubset({'type': 'checkbox', 'name': 'breakpoints', 'value': 'md', 'checked': ''},
input_element.attrs)
input_element = soup.find(id="id_glossary_fluid")
self.assertDictContainsSubset({'type': 'checkbox', 'name': 'fluid'},
input_element.attrs)
container_plugin.save_model(self.request, container_model, form, False)
self.assertListEqual(container_model.glossary['breakpoints'], ['sm', 'md'])
self.assertTrue('fluid' in container_model.glossary)
self.assertEqual(str(container_model), 'for tablets, laptops')
# add a RowPlugin with 1 ColumnPlugin
row_model = add_plugin(self.placeholder, BootstrapRowPlugin, 'en', target=container_model)
row_plugin = row_model.get_plugin_class_instance()
row_change_form = BootstrapRowForm({'num_children': 1})
row_change_form.full_clean()
row_plugin.save_model(self.request, row_model, row_change_form, False)
self.assertDictEqual(row_model.glossary, {})
self.assertIsInstance(row_model, CascadeElement)
column_models = CascadeElement.objects.filter(parent_id=row_model.id)
self.assertEqual(column_models.count(), 1)
# work with the ColumnPlugin
self.column_model = column_models.first()
self.assertIsInstance(self.column_model, CascadeElement)
self.column_plugin = self.column_model.get_plugin_class_instance()
self.assertIsInstance(self.column_plugin, BootstrapColumnPlugin)
self.assertEqual(self.column_model.parent.id, row_model.id)
self.plugin_list = [container_model, row_model, self.column_model]
def resultspage(request):
if request.method == 'GET' and ('has' in request.GET
or 'lacks' in request.GET):
# This is an old-style search we need to support!
has = request.GET.getlist('has')
lacks = request.GET.getlist('lacks')
trans_has = [PROPSV1_TO_TERMSV2[pid] for pid in has]
trans_lacks = [PROPSV1_TO_TERMSV2[pid] for pid in lacks]
qdict = QueryDict('', mutable=True)
qdict.setlist('H', trans_has)
qdict.setlist('L', trans_lacks)
return redirect('{}?{}'.format(reverse('results'), qdict.urlencode()))
elif request.method == 'GET':
has = request.GET.getlist('H')
lacks = request.GET.getlist('L')
has_readable = [forms.term_to_readable(x) for x in has]
lacks_readable = [forms.term_to_readable(x) for x in lacks]
terms = ['H' + item for item in has]
terms.extend(['L' + item for item in lacks])
results, weak_results = ring_search(terms)
is_asymmetric_search = detect_asymmetric_search(terms)
if is_asymmetric_search:
mirror_results, mirror_weak_results = ring_search(
mirror_search_terms(terms))
has_readable = [' '.join(pair) for pair in has_readable]
lacks_readable = [' '.join(pair) for pair in lacks_readable]
else:
has_readable = [pair[0] for pair in has_readable]
lacks_readable = [pair[0] for pair in lacks_readable]
mirror_results, mirror_weak_results = None, None
context = {
'is_asymm_search': is_asymmetric_search,
'results': results,
'weak_results': weak_results,
'mirror_results': mirror_results,
'mirror_weak_results': mirror_weak_results,
'has_readable': has_readable,
'lacks_readable': lacks_readable,
}
return render(request, 'ringapp/results.html', context)
else:
return redirect(reverse('search'))
def make_pixel_qs(request, job=None):
"""
Constructs a query string that will be appended onto a url pointing at
the My.jobs tracking pixel. This qs should contain all of the information
we want to track about this request.
Inputs:
:request: HttpRequest object for this request
:job: the current job, if this is a job detail page
Returns:
:safe_qs: Encoded, and marked safe query string
"""
current_site = settings.SITE
commitments = current_site.special_commitments.all().values_list('commit',
flat=True)
vs = settings.VIEW_SOURCE
if vs:
vs = vs.view_source
else:
vs = 88
qd = QueryDict('', mutable=True)
qd.setlist('st', settings.SITE_TAGS)
qd.setlist('sc', commitments)
qs = {'d': current_site.domain, 'jvs': vs}
if request.path == '/':
qs['pc'] = 'home'
elif job:
qs['pc'] = 'listing'
qs['jvb'] = job.buid if job.buid else 0
qs['jvg'] = job.guid
qs['jvt'] = job.title_exact
qs['jvc'] = job.company_exact
qs['jvl'] = job.location_exact
try:
company = Company.objects.get(name=job.company_exact)
qs['jvcd'] = company.canonical_microsite
except Company.DoesNotExist:
pass
else:
qs['pc'] = 'results'
qs['sl'] = request.REQUEST.get('location', '')
qs['sq'] = request.REQUEST.get('q', '')
qd.update(qs)
safe_qs = mark_safe(qd.urlencode())
return safe_qs
def commresultspage(request):
if request.method == 'GET' and ('has' in request.GET
or 'lacks' in request.GET):
# This is an old-style commutative search we need to support!
has = request.GET.getlist('has')
lacks = request.GET.getlist('lacks')
trans_has = [PROPSV1COMM_TO_TERMSV2[pid] for pid in has]
comm = Property.objects.get(name='commutative')
trans_has.append(comm.id)
trans_lacks = [PROPSV1COMM_TO_TERMSV2[pid] for pid in lacks]
qdict = QueryDict('', mutable=True)
qdict.setlist('H', trans_has)
qdict.setlist('L', trans_lacks)
return redirect('{}?{}'.format(reverse('results'), qdict.urlencode()))
else:
return redirect(reverse('csearch'))
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_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.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)
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(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')
