def get_params(self):
params = self.request.GET
params = [(k, params.get(k)) for k in params if k <> 'page' and \
params.get(k)]
query_dict = QueryDict('', mutable=True)
query_dict.update(dict(params))
return query_dict
def getValues(self, UID):
"""
Function enables to get values from attributes fields and
changes.set fields, return the new values (changes.set > attributes)
"""
try:
self._backend()
valuesUser = self.backend.getUserForObject(self.template, UID)
# Get all attributes from objects:
attributes = LBEAttributeInstance.objects.filter(lbeObjectTemplate=self.template)
d = dict()
for attribute in attributes:
# Only FINAL Attributes:
if attribute.attributeType == 0:
try:
if valuesUser['changes']['set'].has_key(attribute.lbeAttribute.name):
q = QueryDict(attribute.lbeAttribute.name + '=' +
valuesUser['changes']['set'][attribute.lbeAttribute.name][0])
q = q.copy()
for value in valuesUser['changes']['set'][attribute.lbeAttribute.name][1:]:
q.update({attribute.lbeAttribute.name: value})
d[attribute.lbeAttribute.name] = self._compress_data(q)[attribute.lbeAttribute.name]
else:
q = QueryDict(attribute.lbeAttribute.name + '=' +
valuesUser['attributes'][attribute.lbeAttribute.name][0])
q = q.copy()
for value in valuesUser['attributes'][attribute.lbeAttribute.name][1:]:
q.update({attribute.lbeAttribute.name: value})
d[attribute.lbeAttribute.name] = self._compress_data(q)[attribute.lbeAttribute.name]
except BaseException:
d[attribute.lbeAttribute.name] = attribute.defaultValue
return d
except BaseException:
# Create part:
return None
def _verify_postback(self):
# ### Now we don't really care what result was, just whether a flag was set or not.
from paypal.standard.pdt.forms import PayPalPDTForm
response_list = self.response.split('\n')
response_dict = {}
for i, line in enumerate(response_list):
unquoted_line = unquote_plus(line).strip()
if i == 0:
self.st = unquoted_line
else:
if self.st != "SUCCESS":
self.set_flag(line)
break
try:
if not unquoted_line.startswith(' -'):
k, v = unquoted_line.split('=')
response_dict[k.strip()] = v.strip()
except ValueError:
pass
qd = QueryDict('', mutable=True)
qd.update(response_dict)
qd.update(dict(ipaddress=self.ipaddress, st=self.st, flag_info=self.flag_info, flag=self.flag,
flag_code=self.flag_code))
pdt_form = PayPalPDTForm(qd, instance=self)
pdt_form.save(commit=False)
def get(self, request):
data = self.get_data(request)
code = self.get_data(request, "code")
error = self.get_data(request, "error")
client = self.get_data(request, "client")
redirect_uri = data.get('redirect_uri', None) or client.redirect_uri
parsed = urlparse.urlparse(redirect_uri)
query = QueryDict('', mutable=True)
if 'state' in data:
query['state'] = data['state']
if error is not None:
query.update(error)
elif code is None:
query['error'] = 'access_denied'
else:
query['code'] = code
parsed = parsed[:4] + (query.urlencode(), '')
redirect_uri = urlparse.ParseResult(*parsed).geturl()
self.clear_data(request)
return HttpResponseRedirect(redirect_uri)
def get(self, url=None, data=None, **kwargs):
"""Load a web page in the current browser session.
If *url* is None, *self.url* is used.
The querydict can be expressed providing *data* or *kwargs*.
"""
if url is None:
url = self.url
querydict = QueryDict('', mutable=True)
if data is not None:
querydict.update(data)
querydict.update(kwargs)
path = '{0}?{1}'.format(url, querydict.urlencode())
# the following javascript scrolls down the entire page body. Since Twitter
# uses "inifinite scrolling", more content will be added to the bottom of the
# DOM as you scroll... since it is in the loop, it will scroll down up to 100
# times.
# for _ in range(100):
# self.selenium.execute_script("window.scrollTo(0, document.body.scrollHeight);")
# print all of the page source that was loaded
# print self.selenium.page_source.encode("utf-8")
return self.selenium.get(path)
def form_validate(formclass, data, instance=None, commit=True):
'''
Uses a form to validate data passed in as a dictionary. See
http://docs.djangoproject.com/en/dev/ref/forms/validation/
Arguments:
formclass
The class of the form to use
data
A dictionary of data
instance
An existing instance to use to validate
'''
qd = QueryDict({}).copy()
qd.update(data)
form = formclass(qd, instance=instance)
if not form.is_valid():
# If a uuid conflict is the issue, add the conflicting uri to the error message
if 'uuid' in form.errors:
conflicting = form._meta.model.objects.get(uuid = data['uuid'])
if conflicting and hasattr(conflicting, 'get_api_uri'):
form.errors['uri'] = conflicting.get_api_uri()
raise exceptions.APIBadRequest(json.dumps(form.errors))
return form.save(commit=commit)
def test_remove_qs_to_several():
orig = QueryDict(mutable=True)
orig.update({'foo': 'val1'})
orig.update({'foo': 'val2'})
assert dict(orig) == {'foo': ['val1', 'val2']}
params = _remove_qs(orig, foo='val2')
assert dict(params) == {'foo': ['val1']}
def _get_form(self, post_dict=None):
if post_dict:
post = QueryDict('', mutable=True)
post.update(post_dict)
else:
post = None
return get_scheduler_form(post)
def roll(self, **kwargs):
'''
Main router for the app. Passes a randomizer's parameters as JSON
and triggers a result.
'''
if 'session_id' in kwargs:
roll_session = RollSession.objects.get(
session_uuid=kwargs['session_id']).id
query = QueryDict('', mutable=True)
query.update(kwargs['parameters'])
json_args = json.dumps(kwargs['parameters'])
try:
rand = Randomizer.factory(query)
except RandomizerError as error:
self.send(HttpResponseServerError(error))
return
result = rand.get_new_result()
new_roll = RollHistory.objects.create(session_id=roll_session,
roll_input=json_args,
roll_output=json.dumps(result),
roll_date=now())
response = RollHistorySerializer(instance=new_roll).serialize()
self.publish(self.get_subscription_channels(),
{'message': response,
'type': 'single'})
def orders(request):
"""
This is basically like orders/index, but limited to the user
First, filter by the provided search criteria,
then check if we have a saved search filter
then default to user id
Always update saved search filter
"""
args = request.GET.copy()
default = {"state": Order.STATE_OPEN}
if len(args) < 2:
f = request.session.get("account_search_filter", default)
args = QueryDict("", mutable=True)
args.update(f)
# On the profile page, filter by the user, no matter what
args.update({"followed_by": request.user.pk})
request.session["account_search_filter"] = args
data = prepare_list_view(request, args)
data["title"] = _("My Orders")
del (data["form"].fields["assigned_to"])
return render(request, "accounts/orders.html", data)
def get(self, request):
data = self.get_data(request)
code = self.get_data(request, "code")
error = self.get_data(request, "error")
client = self.get_data(request, "client")
redirect_uri = client.redirect_uri # data.get('redirect_uri', None) or
parsed = urlparse.urlparse(redirect_uri)
query = QueryDict("", mutable=True)
if "state" in data:
query["state"] = data["state"]
if error is not None:
query.update(error)
elif code is None:
query["error"] = "access_denied"
else:
query["code"] = code
query["original_path"] = request.GET.get("original_path", "")
parsed = parsed[:4] + (query.urlencode(), "")
redirect_uri = urlparse.ParseResult(*parsed).geturl()
self.clear_data(request)
return HttpResponseRedirect(redirect_uri)
def combine_queries(target_url, request_get):
target_url_parsed = list(urlparse(target_url))
target_url_query = QueryDict(target_url_parsed[4]).copy()
target_url_query.update(request_get)
target_url_parsed[4] = target_url_query.urlencode()
reconstructed_url = urlunparse(target_url_parsed)
return reconstructed_url
def form_validate(formclass, data, instance=None, commit=True):
'''
Uses a form to validate data passed in as a dictionary. See
http://docs.djangoproject.com/en/dev/ref/forms/validation/
Arguments:
formclass
The class of the form to use
data
A dictionary of data
instance
An existing instance to use to validate
'''
qd = QueryDict({}).copy()
qd.update(data)
form = formclass(qd, instance=instance)
if not form.is_valid():
raise exceptions.APIBadRequest(simplejson.dumps(form.errors))
return form.save(commit=commit)
def get_link_context(self, context, obj, admin_site, querystring):
"""
..todo:: document
Always returns the existing context.
"""
site = get_admin_site(admin_site)
if site is None:
logger.debug('Invalid admin site')
return {}
content_type = get_content_type(obj)
new_querystring = QueryDict(querystring, mutable=True)
new_querystring.update({'content_type': content_type.pk,
'content_id': obj.pk})
link = _add_custom_link_to_context(admin_site, context['request'],
opts=EditRegionChunk._meta,
permname='change',
viewname='changelist',
url_params=None,
query=new_querystring.urlencode())
if link['verbose_name']:
logger.debug('link created successfully, swapping out the '
'`verbose_name` available to the context')
link['verbose_name'] = EditRegionChunk._meta.verbose_name_plural
link['obj_name'] = obj._meta.verbose_name
return link
def format_preserving_redirect(request, target, get_dict=None):
"""
If request represents an ajax or embeddable "format", tries
to preserve that for redirects.
Any GET params may be passed through the QueryDict get_dict,
which should be mutable.
"""
my_get_dict = QueryDict('', mutable=True)
if get_dict:
my_get_dict.update(get_dict)
if is_jframe_request(request):
logging.info("JFrame redirection" + target)
my_get_dict['format'] = 'embed'
elif request.ajax:
my_get_dict['format'] = 'json'
param = my_get_dict.urlencode()
if param:
if '?' not in target:
param = '?' + param
else:
param = '&' + param
return HttpResponseRedirect(target + param)
def get_success_url(self):
""" Updates success URL with GET params. """
url = super(StickyGetParamsMixin, self).get_success_url()
scheme, netloc, path, query, fragment = urlsplit(url)
get_params = QueryDict(query, mutable=True)
get_params.update(self.request.GET)
return urlunsplit((scheme, netloc, path, get_params.urlencode(), fragment))
def url_add_query(url, **kwargs):
"""
Lets you append a querystring to a url.
If the querystring argument is already present it will be replaced
otherwise it will be appended to the current querystring.
> url = 'http://example.com/?query=test'
> url_add_query(url, query='abc', foo='bar')
'http://example.com/?query=abc&foo=bar'
It also works with relative urls.
> url = '/foo/?page=1'
> url_add_query(url, query='abc')
'/foo/?query=abc&page=1'
and blank strings
> url = ''
> url_add_query(url, page=2)
'?page=2'
"""
parsed = urlsplit(url)
querystring = QueryDict(parsed.query.encode('utf-8'), mutable=True)
querystring.update(kwargs)
return urlunsplit(parsed._replace(query=querystring.urlencode()))
def get_form_kwargs(self):
kwargs = super(UpdateFormEntryView, self).get_form_kwargs()
#ADD REFERNCE TO FORM OBJECT AND FIELD DATA
kwargs['form_schema'] = self.object
kwargs['request'] = self.request
kwargs['instance'] = self.form_entry_object
if self.request.method in ('POST', 'PUT'):
kwargs.update({
'data': self.request.POST,
'files': self.request.FILES,
})
else:
data = {'form_schema':self.object.pk}
fields = self.form_entry_object.get_entries()
for field in fields:
key = self.form_class.form_field_prefix+field.form_field.slug
data[key] = field.decompressed_value
qdict = QueryDict('', mutable=True)
qdict.update(data)
kwargs['data'] = qdict
return kwargs
def rpc_call(self, request, method=None, **payload):
""" Call REST API with RPC force.
"""
assert method and self.separator in method, \
"Wrong method name: {0}".format(method)
resource_name, method = method.split(self.separator, 1)
assert resource_name in self.api.resources, "Unknown method"
data = QueryDict('', mutable=True)
data.update(payload.get('data', dict()))
data['callback'] = payload.get('callback') or request.GET.get(
'callback') or request.GET.get('jsonp') or 'callback'
for h, v in payload.get('headers', dict()).iteritems():
request.META["HTTP_%s" % h.upper().replace('-', '_')] = v
request.POST = request.PUT = request.GET = data
delattr(request, '_request')
request.method = method.upper()
request.META['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
params = payload.pop('params', dict())
response = self.api.call(resource_name, request, **params)
response.finaly = True
assert response.status_code == 200, response.content
return response
def competition_registration(request, competition_questionset_id):
if request.user.is_authenticated():
return redirect('competition_index',
competition_questionset_id = competition_questionset_id)
if request.method == "POST":
competition = CompetitionQuestionSet.objects.get(
id=competition_questionset_id).competition
d = QueryDict(dict(), mutable=True)
d.update(request.POST)
d['competition'] = competition.id
form = CompetitionRegistrationForm(d)
if form.is_valid():
# print form.cleaned_data
profile = form.save()
u = authenticate(username=profile.user.username,
password=form.cleaned_data['password'])
login(request, u)
request.session['access_code'] = form.cleaned_data[
'access_code']
return redirect('competition_index',
competition_questionset_id = competition_questionset_id)
else:
if request.GET.get('register_as', None) == 'admin':
register_as = 'admin'
else:
register_as = 'competitor'
initial = {'register_as': register_as}
form = CompetitionRegistrationForm(initial = initial)
return render(request,
"bober_simple_competition/competition_registration.html",
locals())
def __call__(self, value, *args, **kwargs):
"""
:param value:
:type value: :class:`list` of :class:`dict`
:return:
:rtype: :class:`django.forms.Form`
"""
if value is None:
return self.form_cls(*args, **kwargs)
post_data = QueryDict("", mutable=True)
file_data = QueryDict("", mutable=True)
for obj in value:
name = obj["name"]
value = obj["value"]
if name in self.form_cls.base_fields and isinstance(
self.form_cls.base_fields[name], FileField
):
mimetypes.init()
basename = os.path.basename(value)
(type_, __) = mimetypes.guess_type(basename)
# it's a file => we need to simulate an uploaded one
content = InMemoryUploadedFile(
io.BytesIO(b"\0"),
name,
basename,
type_ or "application/binary",
1,
"utf-8",
)
file_data.update({name: content})
else:
post_data.update({name: value})
return self.form_cls(post_data, file_data, *args, **kwargs)
def next_redirect(request, default='/', additional_params=None,
next_key='next', redirect_url=None, canvas=False):
from django_facebook import settings as facebook_settings
if facebook_settings.FACEBOOK_DEBUG_REDIRECTS:
return HttpResponse(
'<html><head></head><body><div>Debugging</div></body></html>')
from django.http import HttpResponseRedirect
if not isinstance(next_key, (list, tuple)):
next_key = [next_key]
# get the redirect url
if not redirect_url:
for key in next_key:
redirect_url = request.REQUEST.get(key)
if redirect_url:
break
if not redirect_url:
redirect_url = default
if additional_params:
query_params = QueryDict('', True)
query_params.update(additional_params)
seperator = '&' if '?' in redirect_url else '?'
redirect_url += seperator + query_params.urlencode()
if canvas:
return CanvasRedirect(redirect_url)
return HttpResponseRedirect(redirect_url)
class TestExtractAppData(tests.TestCase):
def setUp(self):
self.query_dict = QueryDict('').copy()
self.app_data = tests.DUMMY_DICT
self.query_dict.update(self.app_data)
def test_empty_app_data(self):
"""
Leave request.GET unchanged if app_data isn't present in
signed_request.
"""
response, request = create_response(test_views.dummy_app_data_view)
self.assertFalse(request.GET, 'GET dict {get} should be empty if there'
' isn‘t any app_data.'.format(get=request.GET))
def test_normal_extraction(self):
"""
Should place content of app_data in request.GET.
"""
response, request = create_response(test_views.dummy_app_data_view,
app_data=self.app_data)
eq_(request.GET, self.query_dict)
def test_preserve_old_get(self):
"""
Preserve previous content of request.GET.
"""
get = {'foo': 'bar!', 'baz': 'fooz!'}
self.query_dict.update(get)
response, request = create_response(test_views.dummy_app_data_view,
get=get, app_data=self.app_data)
eq_(request.GET, self.query_dict)
def test_section(self):
heading_model = add_plugin(self.placeholder, HeadingPlugin, 'en', target=self.column_model)
self.assertIsInstance(heading_model, CascadeElement)
heading_plugin = heading_model.get_plugin_class_instance(self.admin_site)
self.assertIsInstance(heading_plugin, HeadingPlugin)
ModelForm = heading_plugin.get_form(self.request, heading_model)
post_data = QueryDict('', mutable=True)
post_data.update(tag_type='h2', content="Hello", element_id='foo')
form = ModelForm(post_data, None, instance=heading_model)
html = form.as_p()
needle = '<input id="id_glossary_element_id" name="element_id" type="text" value="foo" />'
self.assertInHTML(needle, html)
self.assertTrue(form.is_valid())
heading_plugin.save_model(self.request, heading_model, form, False)
# check identifier
html = heading_plugin.get_identifier(heading_model)
expected = '<code>h2</code>: Hello <code>id="foo"</code>'
self.assertHTMLEqual(html, expected)
# render the Container Plugin with the Heading Plgin as a child
self.plugin_list.append(heading_model)
build_plugin_tree(self.plugin_list)
# context = get_request_context(self.request)
# html = heading_model.render_plugin(context)
html = self.get_html(heading_model, self.get_request_context())
expected = '<h2 id="foo">Hello</h2>'
self.assertHTMLEqual(html, expected)
# add another heading model with the same id
heading_model = add_plugin(self.placeholder, HeadingPlugin, 'en', target=self.column_model)
form = ModelForm(post_data, None, instance=heading_model)
self.assertFalse(form.is_valid())
expected = '<ul class="errorlist"><li>glossary<ul class="errorlist"><li>The element ID 'foo' is not unique for this page.</li></ul></li></ul>'
self.assertHTMLEqual(str(form.errors), expected)
def compete_with_short_code(request, competition_slug):
competition = Competition.objects.get(slug=competition_slug)
class QuestionsetCodeForm(forms.Form):
questionset = forms.ModelChoiceField(
queryset = CompetitionQuestionSet.objects.filter(
competition = competition))
access_code = forms.CharField()
qd = QueryDict(dict(), mutable=True)
qd.update(request.GET)
qd.update(request.POST)
if len(qd):
form = QuestionsetCodeForm(qd)
else:
form = QuestionsetCodeForm()
if form.is_valid():
# defer_update = form.cleaned_data['defer_update_used_codes']
# defer_effects = form.cleaned_data['defer_effects']
cqs = form.cleaned_data['questionset']
access_code = competition.expand_competitor_code(
short_code = form.cleaned_data['access_code'],
competition_questionset = cqs)
_use_access_code(request, access_code,
defer_update_used_codes=False, defer_code_effects=False)
return HttpResponseRedirect(reverse('competition_index',
kwargs = {'competition_questionset_id': cqs.id}))
return render(request, 'bober_simple_competition/compete_with_short_code.html', locals())
def _get_nodes(request, graph_id, query={}):
"""
Query Parameters
----------
graph_id : string
Unique ID of the graph.
limit : integer
Number of entities to return. Default value is 20.
offset : integer
Offset the list of returned entities by this number. Default value is 0.
names : list of strings
Search for groups with given names. In order to search for groups with given name as a substring, wrap the name with percentage symbol. For example, %xyz% will search for all groups with xyz in their name.
labels : list of strings
Search for groups with given labels. In order to search for groups with given label as a substring, wrap the label with percentage symbol. For example, %xyz% will search for all groups with xyz in their label.
order : string
Defines the column sort order, can only be 'asc' or 'desc'.
sort : string
Defines which column will be sorted.
Parameters
----------
request : object
HTTP GET Request.
Returns
-------
total : integer
Number of nodes matching the request.
nodes : List of nodes.
List of Node Objects with given limit and offset.
Raises
------
Notes
------
"""
authorization.validate(request, permission='GRAPH_READ', graph_id=graph_id)
querydict = QueryDict('', mutable=True)
querydict.update(query)
query = querydict
total, nodes_list = graphs.search_nodes(request,
graph_id=graph_id,
names=query.getlist('names[]', None),
labels=query.getlist('labels[]', None),
limit=query.get('limit', 20),
offset=query.get('offset', 0),
order=query.get('order', 'desc'),
sort=query.get('sort', 'name'))
return {
'total': total,
'nodes': [utils.serializer(node) for node in nodes_list]
}
def get_json_parameters(request):
result = QueryDict('', mutable=True)
if hasattr(request, 'data'):
result.update(request.data)
else:
result.update(request.body)
return result
def process_request(self, request):
if 'application/json' in request.META.get('CONTENT_TYPE', ''):
# load the json data
data = json.loads(request.body)
# for consistency sake, we want to return
# a Django QueryDict and not a plain Dict.
# The primary difference is that the QueryDict stores
# every value in a list and is, by default, immutable.
# The primary issue is making sure that list values are
# properly inserted into the QueryDict. If we simply
# do a q_data.update(data), any list values will be wrapped
# in another list. By iterating through the list and updating
# for each value, we get the expected result of a single list.
q_data = QueryDict('', mutable=True)
for key, value in data.iteritems():
print value
if isinstance(value, list):
# need to iterate through the list and update
# so that the list does not get wrapped in an
# additional list.
for x in value:
q_data.update({key: x})
else:
q_data.update({key: value})
if request.method == 'GET':
request.GET = q_data
if request.method == 'POST':
request.POST = q_data
return None
def alias_view(request, *args, **kwargs):
"""
This is the view that takes care of all URLs other than those beginning
with "/static/", "/viewing/", and those URLs taken by modules.
It checks all of the ViewerRequests to see if any match the current URL,
and if so, simulates a request to the given viewer.
"""
cur_site = get_current_site(request)
path_parts = [x for x in request.path.split("/") if x] # Reduce consecutive slashes
viewer_request = cur_site
try:
for path_part in path_parts:
viewer_request = CustomUrl.objects.get(path=path_part, parent_url=viewer_request)
except ObjectDoesNotExist:
viewer = ItemViewer()
viewer.init_for_http(request, "error", None, "html")
url = "http://%s%s" % (request.get_host(), request.path)
return viewer.render_error(
"Page Not Found", "We could not find any page matching your URL %s" % url, HttpResponseNotFound
)
item = viewer_request.aliased_item
kwargs = {}
kwargs["viewer"] = viewer_request.viewer
kwargs["format"] = viewer_request.format
kwargs["action"] = viewer_request.action
kwargs["noun"] = str(item.pk) if item else None
query_dict = QueryDict(viewer_request.query_string).copy()
query_dict.update(request.GET)
request.GET = query_dict
# Set the REQUEST dict
request._request = datastructures.MergeDict(request.POST, request.GET)
return item_view(request, **kwargs)
def form_valid(self, form):
"""
The request from ulogin service is correct
"""
response = self.ulogin_response(form.cleaned_data['token'],
self.request.get_host())
if 'error' in response:
return render(self.request, self.error_template_name,
{'json': response})
if self.request.user.is_authenticated():
user, identity, registered = \
self.handle_authenticated_user(response)
else:
user, identity, registered = \
self.handle_anonymous_user(response)
assign.send(sender=ULoginUser,
user=self.request.user,
request=self.request,
registered=registered,
ulogin_user=identity,
ulogin_data=response)
if registered or not user.is_active:
query_dict = QueryDict('').copy()
if self.request.GET.get(REDIRECT_FIELD_NAME):
query_dict.update({REDIRECT_FIELD_NAME: self.request.GET[REDIRECT_FIELD_NAME]})
return redirect('%s?%s' % (reverse(s.REGISTER_VIEW),
query_dict.urlencode(safe='/')))
return redirect(self.request.GET.get(REDIRECT_FIELD_NAME) or '/')
def test_model_multiple_choice_field_chip():
obj_1 = Category.objects.get_or_create(name='test-1', slug='test-1')[0]
obj_2 = Category.objects.get_or_create(name='test-2', slug='test-2')[0]
data = QueryDict(mutable=True)
data.update({'categories': obj_1.pk})
data.update({'categories': obj_2.pk})
filter_set = ModelMultipleChoiceFieldFilterSet(
data, queryset=Product.objects.all())
field = filter_set.form['categories']
items = handle_multiple_model_choice(field, data)
assert len(items) == 2
chip_1 = items[0]
assert chip_1['content'] == CHIPS_PATTERN % ('Category', str(obj_1))
assert 'categories=%s' % obj_1.pk not in chip_1['link']
assert 'categories=%s' % obj_2.pk in chip_1['link']
chip_2 = items[1]
assert chip_2['content'] == CHIPS_PATTERN % ('Category', str(obj_2))
assert 'categories=%s' % obj_2.pk not in chip_2['link']
assert 'categories=%s' % obj_1.pk in chip_2['link']
def mailing_list(request, key=None):
if not key:
raise Http404("Page not found")
session_key = request.session.pop("key", None)
form = request.session.pop("form", None)
if (key and form):
qdict = QueryDict('')
qdict = qdict.copy()
qdict.update(form)
form = MailingListForm(qdict)
if session_key == key and form.is_valid():
object = form.save()
return render(request, 'mailinglist/mailing_verify.html', {
"success": True,
"object": object
})
else:
return render(request, 'mailinglist/mailing_verify.html',
{"success": False})
return render(request, 'mailinglist/mailing_verify.html',
{"success": False})
def _init_options(self):
# sometimes self.data is a plain dict instead of a QueryDict
data = QueryDict(mutable=True)
data.update(self.data)
# update available choices based on instances in self._selection
if self._selection and hasattr(self._selection, 'lines'):
options = table.TableOptions(models.Line,
instances=self._selection.lines)
self.fields['line_meta'].choices = options.choices
self.fields['line_meta'].coerce = options.coerce
# set all _meta options if no list of options was passed in
for meta in [
'study_meta', 'line_meta', 'protocol_meta', 'assay_meta',
'measure_meta'
]:
if self.initial.get(meta, None) == '__all__':
self.initial.update({
meta: [choice[0] for choice in self.fields[meta].choices],
})
# update incoming data with default initial if not already set
if meta not in data and 'layout' not in data:
data.setlist(meta, self.initial.get(meta, []))
self.data = data
def form_valid(self, form):
latlng = self.geocode_location(form.cleaned_data['location'])
if latlng:
qs = QueryDict('', mutable=True)
qs.update({
'search_type': form.cleaned_data['search_type'],
'min_price': form.cleaned_data['min_price'],
'max_price': form.cleaned_data['max_price'],
'location': form.cleaned_data['location'],
'min_bedrooms': form.cleaned_data['min_bedrooms'],
'property_type': form.cleaned_data['property_type'].slug,
'latitude': latlng[0],
'longitude': latlng[1],
'distance': 10
})
if form.cleaned_data['search_type'] == 'lettings':
return HttpResponseRedirect(
reverse('lettings:search') + '?' + qs.urlencode())
else:
return HttpResponseRedirect(
reverse('sales:search') + '?' + qs.urlencode())
else:
return HttpResponseRedirect('/search/error')
def validate_set_password_form(window_info, data=None):
"""Dynamically validate the SetPasswordForm (for self-modifying its password) class.
.. code-block:: javascript
$.dfws.df.validate.set_password({data: $(this).serializeArray()}).then(function (r) {console.log(r); })
"""
query_dict = QueryDict("", mutable=True)
for obj in data:
query_dict.update({obj["name"]: obj["value"]})
form = SetPasswordForm(window_info.user, query_dict)
valid = form.is_valid()
return {
"valid": valid,
"errors": {
f: e.get_json_data(escape_html=False)
for f, e in form.errors.items()
},
"help_texts":
{f: e.help_text
for (f, e) in form.fields.items() if e.help_text},
}
def test_model_multiple_choice_field_chip():
obj_1 = Category.objects.get_or_create(name="test-1", slug="test-1")[0]
obj_2 = Category.objects.get_or_create(name="test-2", slug="test-2")[0]
data = QueryDict(mutable=True)
data.update({"categories": obj_1.pk})
data.update({"categories": obj_2.pk})
filter_set = ModelMultipleChoiceFieldFilterSet(
data, queryset=Product.objects.all())
field = filter_set.form["categories"]
items = handle_multiple_model_choice(field, data)
assert len(items) == 2
chip_1 = items[0]
assert chip_1["content"] == CHIPS_PATTERN % ("Category", str(obj_1))
assert "categories=%s" % obj_1.pk not in chip_1["link"]
assert "categories=%s" % obj_2.pk in chip_1["link"]
chip_2 = items[1]
assert chip_2["content"] == CHIPS_PATTERN % ("Category", str(obj_2))
assert "categories=%s" % obj_2.pk not in chip_2["link"]
assert "categories=%s" % obj_1.pk in chip_2["link"]
def obtain_tokens(
cls: APITestCase,
credentials: Dict[str, str],
query_args: Optional[Dict[str,
str]] = None) -> Tuple[str, str, Response]:
""" Attempts to obtain a token pair for a set of credentials """
url = reverse("tokens:obtain_delete")
if query_args:
q = QueryDict("", mutable=True)
q.update(query_args)
url = "{base_url}?{query_args}".format(
base_url=url,
query_args=q.urlencode(),
)
res = cls.client.post(url, data=credentials)
if not res.status_code == status.HTTP_200_OK:
raise ValueError("Provided testing credentials invalid.")
content = res.json()
access_token = content.get("access")
refresh_token = content.get("refresh", None)
return access_token, refresh_token, res
def post_comment(request, id):
article = get_object_or_404(Article, id=id)
# 处理 POST 请求
if request.method == 'POST':
ip = base64.b64encode(request.META['REMOTE_ADDR'].encode())
data = QueryDict(mutable=True)
data.update(request.POST)
data.update({'user': '******' + '_' + ip.decode()})
print(data)
comment_form = CommentForm(data)
if comment_form.is_valid():
new_comment = comment_form.save(commit=False)
new_comment.article = article
new_comment.save()
return redirect(article)
else:
#print(comment_form.clean_data)
print(comment_form.errors.as_data())
return HttpResponse("表单内容有误，请重新填写。")
# 处理错误请求
else:
return HttpResponse("发表评论仅接受POST请求。")
def submit_url(self, params={}, defaults=True):
"""
Return a form submit url with the given params.
"""
action = self.attr('action')
values = QueryDict('', mutable=True)
if defaults:
for el in self.find('input'):
if el.get('type') in ('checkbox', 'radio'):
if el.get('checked'):
values.appendlist(el.name, el.value or '')
else:
values.appendlist(el.name, el.value or '')
#overwrite the querydict
if isinstance(params, QueryDict):
values.update(params)
else:
for key, val in params.items():
if val is None:
del values[key]
else:
values[key] = val
return self.absolute_url(action or '') + '?' + values.urlencode()
def process_request(self, request):
if 'application/json' in request.META['CONTENT_TYPE']:
# load the json data
data = json.loads(request.body)
q_data = QueryDict('', mutable=True)
for key, value in data.iteritems():
if isinstance(value, list):
# need to iterate through the list and upate
# so that the list does not get wrapped in an
# additional list.
for x in value:
q_data.update({key: x})
else:
q_data.update({key: value})
if request.method == 'GET':
request.GET = q_data
if request.method == 'POST':
request.POST = q_data
return None
def signup_view(request):
if request.user.is_authenticated():
return redirect(reverse('home_projects'))
if request.method == 'POST':
post = request.POST
form = UserCreationForm(post)
if form.is_valid():
form.save()
new_post = QueryDict(mutable=True)
new_post.update(post)
new_post['password'] = post['password1']
request.POST = new_post
return login_view(request)
else:
log.warn(form.is_valid())
log.warn(form.errors)
else:
form = UserCreationForm()
token = {}
token.update(csrf(request))
token['form'] = form
return render(request, 'signup.html', token)
def test_accounts_login(client, request_users, settings):
user = request_users["user"]
if user.username == "nobody":
return
settings.POOTLE_CAPTCHA_ENABLED = False
password = request_users["password"]
qdict = QueryDict(mutable=True)
qdict.update(
{'login': user.username,
'password': password})
qdict._mutable = False
response = client.post(
'/accounts/login/',
qdict,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
email = EmailAddress.objects.filter(user=user, primary=True).first()
assert response.request['PATH_INFO'] == '/accounts/login/'
assert response.status_code == 200
if email is not None and email.verified:
assert response.json() == {u"location": "/"}
else:
assert response.json() == {u"location": "/accounts/confirm-email/"}
def rpc_call(self, request, method=None, **payload):
""" Call REST API with RPC force.
return object: a result
"""
if not method or self.separator not in method:
raise AssertionError("Wrong method name: {0}".format(method))
resource_name, method = method.split(self.separator, 1)
if resource_name not in self.api.resources:
raise AssertionError("Unknown method " + method)
data = QueryDict('', mutable=True)
data.update(payload.get('data', dict()))
data['callback'] = payload.get('callback') or request.GET.get(
'callback') or request.GET.get('jsonp') or 'callback'
for h, v in payload.get('headers', dict()).iteritems():
request.META["HTTP_%s" % h.upper().replace('-', '_')] = v
request.POST = request.PUT = request.GET = data
delattr(request, '_request')
request.method = method.upper()
request.META['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
params = payload.pop('params', dict())
response = self.api.call(resource_name, request, **params)
if not isinstance(response, SerializedHttpResponse):
return response
if response['Content-type'] in self._meta.emitters_dict:
return HttpResponse(response.content, status=response.status_code)
if response.status_code == 200:
return response.response
raise AssertionError(response.response)
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 create(self, request):
print(request.data)
room_id = request.data.get('room')
room = Room.objects.all().get(pk=room_id)
building = Building.objects.all().get(pk=room.building.id_text)
eventData = getEvents(building.id_text, room.room_num)
def sendRequests(data):
serializer = self.serializer_class(data=data)
if serializer.is_valid():
newEvent = Event(room = room, start_time = data.get('start_time'), \
end_time = data.get('end_time'), event_name = data.get('event_name'))
if not Event.objects.filter(
room=room, start_time=data.get('start_time')).exists():
newEvent.save()
else:
return Response(data, status=status.HTTP_409_CONFLICT)
return Response(data, status=status.HTTP_201_CREATED)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
summary = QueryDict('', mutable=True)
summary.update({"events written": len(eventData)})
remainingEvents = len(eventData)
if (remainingEvents == 0):
return Response(summary, status=status.HTTP_204_NO_CONTENT)
while remainingEvents > 0:
data = request.data.copy()
data.update(eventData[remainingEvents - 1])
remainingEvents -= 1
sendRequests(data)
return Response(summary, status=status.HTTP_201_CREATED)
def staticmap_url(self):
if not self.child_plugin_instances:
return None
def clean_size(size):
if size.endswith('px'):
return int(size.replace('px', ''))
return 1000 # default
qdict = QueryDict('', mutable=True)
qdict.update({
'key': GOOGLE_MAPS_API_KEY,
'size': '{}x{}'.format(
clean_size(self.width),
clean_size(self.height)
),
'maptype': self.map_type,
'language': get_current_language()
})
if self.zoom:
qdict['zoom'] = self.zoom
query = qdict.urlencode()
for location in self.child_plugin_instances or []:
if not hasattr(location, 'get_lat_lng'):
continue
lat_lng = location.get_lat_lng()
location = (
','.join(map(str, lat_lng)) if lat_lng else
' '.join((location.address, location.zipcode, location.city))
)
query += '&markers={}'.format(urlencode(location))
return '{}?{}'.format(GOOGLE_MAPS_STATICMAPS_URL, query)
def _json_write_to_file(parent, field, request, serializer):
json_serializer = serializer()
data = json_serializer.validate(request.data)
# create file object
with open(json_serializer.filenmame, 'wb+') as f:
in_memory_file = UploadedFile(file=f,
name=json_serializer.filenmame,
content_type='application/json',
size=len(data.encode('utf-8')),
charset=None)
# wrap and re-open file
file_obj = QueryDict('', mutable=True)
file_obj.update({'file': in_memory_file})
file_obj['file'].open()
file_obj['file'].seek(0)
file_obj['file'].write(data.encode('utf-8'))
serializer = RelatedFileSerializer(data=file_obj,
content_types='application/json',
context={'request': request})
serializer.is_valid(raise_exception=True)
instance = serializer.create(serializer.validated_data)
# Check for exisiting file and delete
_delete_related_file(parent, field)
setattr(parent, field, instance)
parent.save(update_fields=[field])
# Override 'file' return to hide storage details with stored filename
response = Response(
RelatedFileSerializer(instance=instance,
content_types='application/json').data)
response.data['file'] = instance.file.name
return response
def test_admin_app_save_related_collections(self, post_request,
osf_user_admin, user,
preprint):
""" Testing OSFUserAdmin.save_related
This should maintain the bookmark collections and preprint groups the user is a member of
even though they aren't explicitly returned by the form.
"""
form = osf_user_admin.get_form(request=post_request, obj=user)
data_dict = model_to_dict(user)
post_form = form(data_dict, instance=user)
# post_form.errors.keys() generates a list of fields causing JSON Related errors
# which are preventing the form from being valid (which is required for the form to be saved).
# By setting the field to '{}', this makes the form valid and resolves JSON errors.
for field in post_form.errors.keys():
if field == 'groups':
data_dict['groups'] = []
else:
data_dict[field] = '{}'
post_form = form(data_dict, instance=user)
assert (post_form.is_valid())
post_form.save(commit=False)
qdict = QueryDict('', mutable=True)
qdict.update(data_dict)
post_request.POST = qdict
osf_user_admin.save_related(request=post_request,
form=post_form,
formsets=[],
change=True)
collections_group = Collection.objects.filter(
creator=user, is_bookmark_collection=True)[0].get_group('admin')
assert (collections_group in user.groups.all())
assert (preprint.get_group('admin') in user.groups.all())
def __init__(self, *args, **kwargs):
kwargs.setdefault('label_suffix', '')
if "data" in kwargs:
q = QueryDict('', mutable=True)
q.update(kwargs["data"])
initial = dict()
initial["from_advisor"] = str(kwargs["initial"]["from_advisor"].pk)
q.update(initial)
kwargs["data"] = q
super(SingleInvestorTransferForm, self).__init__(*args, **kwargs)
self.field_sections = [
{
"fields": ('to_advisor', ),
"header": "To Advisor"
},
{
"fields": ('investor', ),
"header": "Investor"
},
{
"fields": ('signatures', ),
"header":
"Signatures",
"detail":
mark_safe(
"Signatures of the investor and the previous advisor: if this is "
"for a Joint Account the signature of the second investor "
"is required. <a target='_blank' href='/static/docs/advisor_single_transferer_signatures.pdf'>Example</a>"
)
},
]
self.fields["investor"].queryset = self.initial["from_advisor"].clients
self.fields["to_advisor"].queryset = Advisor.objects.filter(
firm=self.initial["from_advisor"].firm)
def reprogramar(request, id_turno):
if not request.user.is_authenticated:
response_dict = {'status': 0, 'message': err_ses}
return JsonResponse(response_dict)
observacion_turno = request.GET['observacion_turno']
try:
turno = Turno.objects.get(id=id_turno)
if turno.estado.id != Estado.ANULADO:
turno.estado = Estado.objects.get(id=Estado.ANULADO)
if observacion_turno:
turno.observacion = observacion_turno
turno.save()
turno_channel_msg(turno, 'ANULA')
add_log_entry(turno, request.user, CHANGE, "REPROGRAMA")
practicas = turno.practicas.all()
# generamos una estructura de datos similar a request.GET
data = QueryDict('', mutable=True)
data.update({
'id-sala': turno.sala.id,
'id-paciente': turno.paciente.id,
'id-medico': turno.medico.id,
'id-obra-social': turno.obraSocial.id
})
data.setlist('id-practicas[]', [str(practica.id) for practica in practicas])
return _get_turnos_disponibles(request.user, data)
except Turno.DoesNotExist:
return get_buscar_turnos(request)
except Exception as err:
return str(err)
def signup_view(request):
if request.user.is_authenticated():
return redirect('/')
if request.method == 'POST':
post = request.POST
form = UserCreationForm(post)
if form.is_valid():
form.save()
new_post = QueryDict(mutable=True)
new_post.update(post)
new_post['password'] = post['password1']
request.POST = new_post
return login_view(request)
else:
log.info("Invalid request: {}".format(', '.join(
form.error_messages)))
else:
form = UserCreationForm()
token = {}
token.update(csrf(request))
token['form'] = form
return render(request, 'signup.html', token)
def dispatch(self, request, *args, **kwargs):
if not request.GET.get('_transform', False):
"""
The purpose of this mixin is to add the <code data-enlighter-language="generic" class="EnlighterJSRAW">case-transformation</code> renderers and parsers
only in case it's forced from the client (putting the '_transform' GET kwarg). If the client
wants the data in the <code data-enlighter-language="generic" class="EnlighterJSRAW">snake_case</code> format we just put the default renderers and parsers.*
* Check: https://github.com/encode/django-rest-framework/blob/master/rest_framework/views.py#L97
"""
self.renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
self.parser_classes = api_settings.DEFAULT_PARSER_CLASSES
else:
# Make request's GET QueryDict mutable
request.GET._mutable = True
# Delete <code data-enlighter-language="generic" class="EnlighterJSRAW">_transofrm</code> key since we don't need it
del request.GET['_transform']
# Convert query params to snake_case
request_get_dict = deep_snake_case_transform(request.GET.dict())
# The following lines puts the snake_cased params back to the request.GET
# https://docs.djangoproject.com/en/2.0/ref/request-response/#django.http.QueryDict.update
request_get = QueryDict('', mutable=True)
request_get.update(request_get_dict)
request_get._mutable = False
request.GET = request_get
return super().dispatch(request, *args, **kwargs)
def test_generic_report_with_units_success(self, mock_handler):
"""Test unit conversion succeeds in generic report."""
mock_handler.return_value.execute_query.return_value = self.report
params = {
'group_by[account]': '*',
'filter[resolution]': 'monthly',
'filter[time_scope_value]': '-1',
'filter[time_scope_units]': 'month',
'units': 'byte',
'SERVER_NAME': ''
}
user = User.objects.get(
username=self.user_data['username']
)
django_request = HttpRequest()
qd = QueryDict(mutable=True)
qd.update(params)
django_request.GET = qd
request = Request(django_request)
request.user = user
response = _generic_report(request, provider='aws', report='costs')
self.assertIsInstance(response, Response)
def test_search_on_external_cograduation(self):
data = QueryDict(mutable=True)
academic_year = self.academic_years[0]
data.update({
"academic_year_id": str(academic_year.id),
"container_type": learning_container_year_types.EXTERNAL
})
ExternalLearningUnitYearFactory(
learning_unit_year__academic_year=academic_year,
learning_unit_year__learning_container_year__container_type=
learning_container_year_types.EXTERNAL,
mobility=True,
co_graduation=False,
)
ExternalLearningUnitYearFactory(
learning_unit_year__academic_year=academic_year,
learning_unit_year__learning_container_year__container_type=
learning_container_year_types.EXTERNAL,
mobility=False,
co_graduation=True,
)
form = LearningUnitYearForm(data)
self.assertTrue(form.is_valid())
self.assertEqual(form.get_queryset().count(), 1)
def test_simple_export(self):
storage = broker.ExportBroker(self.user.id)
params = QueryDict(mutable=True)
params.update(studyId=self.study.id)
path = storage.save_params(params)
export_id = tasks.export_table_task.s(self.user.id, path).apply()
result = storage.load_export(export_id.result)
with io.TextIOWrapper(io.BytesIO(result), encoding="utf-8") as file:
rows = list(csv.reader(file))
# header row + (10 lines * 3 assays * 3 types) + blank row
assert len(rows) == 92
assert rows[91] == []
assert rows[0] == [
"Study ID",
"Study Name",
"Study Description",
"Study Contact",
"Line ID",
"Line Name",
"Line Description",
"Control",
"Strain(s)",
"Line Experimenter",
"Line Contact",
"Protocol ID",
"Protocol Name",
"Assay ID",
"Assay Name",
"Type",
"Formal Type ID",
"Measurement Updated",
"X Units",
"Y Units",
"12.0",
]
def test_save_projects(self):
'''PowerPlantForm correctly saves a PowerPlant's Projects.'''
power_plant = PowerPlantFactory()
project1 = ProjectFactory()
project2 = ProjectFactory()
with self.subTest('Adding projects with a QueryDict'):
data = QueryDict(mutable=True)
data.update({'name': power_plant.name, 'slug': power_plant.slug})
data.update(projects=project1.id)
data.update(projects=project2.id)
form = PowerPlantForm(instance=power_plant, data=data)
self.assertTrue(form.is_valid())
updated_powerplant = form.save()
self.assertEqual(set(updated_powerplant.project_set.all()), set([project1, project2]))
with self.subTest('Removing Projects with a QueryDict'):
data = QueryDict(mutable=True)
data.update({'name': power_plant.name, 'slug': power_plant.slug})
data.update(projects=project1.id)
form = PowerPlantForm(instance=power_plant, data=data)
self.assertTrue(form.is_valid())
updated_powerplant = form.save()
self.assertEqual(set(updated_powerplant.project_set.all()), set([project1]))
with self.subTest('Adding projects with a dictionary'):
data = {
'name': power_plant.name,
'slug': power_plant.slug,
'projects': [project1, project2],
}
form = PowerPlantForm(instance=power_plant, data=data)
self.assertTrue(form.is_valid())
updated_powerplant = form.save()
self.assertEqual(set(updated_powerplant.project_set.all()), set([project1, project2]))
with self.subTest('Removing Projects with a dictionary'):
data['projects'] = [project1]
form = PowerPlantForm(instance=power_plant, data=data)
self.assertTrue(form.is_valid())
updated_powerplant = form.save()
self.assertEqual(set(updated_powerplant.project_set.all()), set([project1]))
def show_game_info(request, gid):
game = Game.objects.get(pk=gid)
comments = Comment.objects.filter(gid=gid)
form = None
if request.user.is_authenticated:
user_comment = Comment.objects.filter(gid=gid, made_by=request.user)
comment_details = {}
if user_comment:
comment_details['comment'] = user_comment[0].content
comment_details['rating'] = user_comment[0].rating
comment_details['commid'] = user_comment[0].commid
comment_details['exists'] = 1
else:
comment_details['rating'] = 3
form = QueryDict('', mutable=True)
form.update(comment_details)
return render(request, 'show-game-info.html', {
'game': game,
'comments': comments,
'form': form
})
def create(self, request, *args, **kwargs):
# If the object ID was not specified, it probably doesn't exist in the
# DB yet. We want to see if we can create it. The URL may choose to
# inject it's primary key into the object because we are posting to a
# subcollection. Use all the normal access control mechanisms.
# Make a copy of the data provided (since it's readonly) in order to
# inject additional data.
if hasattr(request.data, 'copy'):
data = request.data.copy()
else:
data = QueryDict('')
data.update(request.data)
# add the parent key to the post data using the pk from the URL
parent_key = getattr(self, 'parent_key', None)
if parent_key:
data[parent_key] = self.kwargs['pk']
# attempt to deserialize the object
serializer = self.get_serializer(data=data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
# Verify we have permission to add the object as given.
if not request.user.can_access(self.model, 'add', serializer.initial_data):
raise PermissionDenied()
# save the object through the serializer, reload and returned the saved
# object deserialized
obj = serializer.save()
serializer = self.get_serializer(instance=obj)
headers = {'Location': obj.get_absolute_url(request)}
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def next_redirect(request,
default='/',
additional_params=None,
next_key='next'):
from django.http import HttpResponseRedirect
if not isinstance(next_key, (list, tuple)):
next_key = [next_key]
#get the redirect url
redirect_url = None
for key in next_key:
redirect_url = request.REQUEST.get(key)
if redirect_url:
break
if not redirect_url:
redirect_url = default
if additional_params:
query_params = QueryDict('', True)
query_params.update(additional_params)
seperator = '&' if '?' in redirect_url else '?'
redirect_url += seperator + query_params.urlencode()
return HttpResponseRedirect(redirect_url)
def test_costview_with_units_success(self, mock_handler):
"""Test unit conversion succeeds in AzureCostView."""
mock_handler.return_value.execute_query.return_value = self.report
params = {
'group_by[subscription_guid]': '*',
'filter[resolution]': 'monthly',
'filter[time_scope_value]': '-1',
'filter[time_scope_units]': 'month',
'units': 'byte',
'SERVER_NAME': ''
}
user = User.objects.get(
username=self.user_data['username']
)
django_request = HttpRequest()
qd = QueryDict(mutable=True)
qd.update(params)
django_request.GET = qd
request = Request(django_request)
request.user = user
response = AzureCostView().get(request)
self.assertIsInstance(response, Response)
