def get_oauth_url(request, scope, redirect_uri=None, extra_params=None): ''' Returns the oauth url for the given request and scope Request maybe shouldnt be tied to this function, but for now it seems rather ocnvenient ''' from django_facebook import settings as facebook_settings scope = parse_scope(scope) query_dict = QueryDict('', True) query_dict['scope'] = ','.join(scope) query_dict['client_id'] = facebook_settings.FACEBOOK_APP_ID redirect_uri = redirect_uri or request.build_absolute_uri() current_uri = redirect_uri # set attempt=1 to prevent endless redirect loops if 'attempt=1' not in redirect_uri: if '?' not in redirect_uri: redirect_uri += '?attempt=1' else: redirect_uri += '&attempt=1' query_dict['redirect_uri'] = redirect_uri oauth_url = 'https://www.facebook.com/dialog/oauth?' oauth_url += query_dict.urlencode() return oauth_url, current_uri, redirect_uri
def test_mutable_copy(self): """A copy of a QueryDict is mutable.""" q = QueryDict().copy() with self.assertRaises(KeyError): q.__getitem__("foo") q['name'] = 'john' self.assertEqual(q['name'], 'john')
def test_https_login_url(self): login_url = 'https:///login/' login_required_url = self.get_login_required_url(login_url) querystring = QueryDict('', mutable=True) querystring['next'] = 'http://testserver/login_required/' self.assertEqual(login_required_url, '%s?%s' % (login_url, querystring.urlencode('/')))
def buildRequestUrl(self): qd = QueryDict("", mutable=True) for key in Quattro.QUERY_STRING_KEYS: value = getattr(self, key, None) if value: qd[key] = value return Quattro.QUATTRO_URL + "?" + qd.urlencode()
def test_login_url_with_querystring(self): login_url = '/login/?pretty=1' login_required_url = self.get_login_required_url(login_url) querystring = QueryDict('pretty=1', mutable=True) querystring['next'] = '/login_required/' self.assertEqual(login_required_url, 'http://testserver/login/?%s' % querystring.urlencode('/'))
def get_oauth_url(request, scope, redirect_uri=None): ''' Returns the oauth url for the given request and scope Request maybe shouldnt be tied to this function, but for now it seems rather ocnvenient ''' from django_facebook import settings as facebook_settings scope = parse_scope(scope) query_dict = QueryDict('', True) query_dict['scope'] = ','.join(scope) query_dict['client_id'] = facebook_settings.FACEBOOK_APP_ID redirect_uri = redirect_uri or request.build_absolute_uri() #set attempt=1 to prevent endless redirect loops if 'attempt=1' not in redirect_uri: if '?' not in redirect_uri: redirect_uri += '?attempt=1' else: redirect_uri += '&attempt=1' if ('//localhost' in redirect_uri or '//127.0.0.1' in redirect_uri) and settings.DEBUG: raise ValueError, 'Facebook checks the domain name of your apps. Therefor you cannot run on localhost. Instead you should use something like local.fashiolista.com. Replace Fashiolista with your own domain name.' query_dict['redirect_uri'] = redirect_uri url = 'https://www.facebook.com/dialog/oauth?' url += query_dict.urlencode() return url, redirect_uri
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 get_job_detail_breadbox(request, job_id): job = get_job(request, job_id) if not job: return {} site_config = get_site_config(request) breadbox = helpers.job_breadcrumbs(job, site_config.browse_company_show) query_string = get_query_string(request) if query_string: # Append the query_path to all of the exising urls for field in breadbox: path = breadbox[field].get('path', '/jobs/') path_and_query_string = "%s?%s" % (path, query_string) new_url = (path_and_query_string if query_string else breadbox[field]['path']) breadbox[field]['path'] = new_url # Create a new path for title and moc query string values # from the job information. fields = ['title', 'city'] path = '' for field in fields: slab = getattr(job, '%s_slab' % field) path = "%s%s/" % (path, slab.split("::")[0]) for field in ['q', 'moc']: if request.GET.get(field, None): breadbox[field] = {} qs = QueryDict(query_string).copy() del qs[field] breadbox[field]['path'] = "/%s?%s" % (path, qs.urlencode()) breadbox[field]['display'] = request.GET.get(field) return breadbox
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 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 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)
def test_add(self): """ Test adding a plugin to a *PAGE*. """ page, placeholder, superuser, staff = self.get_data() get_data = { 'plugin_type': "TextPlugin", 'plugin_language': settings.LANGUAGES[0][0], 'placeholder_id': page.placeholders.get(slot="body").pk, } post_data = {} self.assertEqual(CMSPlugin.objects.count(), 0) # log the user out and post the plugin data to the cms add-plugin URL. self.client.logout() add_url = URL_CMS_PLUGIN_ADD + '?' + urlencode(get_data) response = self.client.post(add_url, post_data) # since the user is not logged in, they should be prompted to log in. self.assertEqual(response.status_code, 302) querystring = QueryDict('', mutable=True) querystring['next'] = add_url expected_url = '/{lang}/admin/login/?{next}'.format( lang=settings.LANGUAGES[0][0], next=querystring.urlencode(safe='/') ) self.assertRedirects(response, expected_url) self.assertEqual(CMSPlugin.objects.count(), 0) # now log a staff user without permissions in and do the same as above. self.client.login(username=getattr(staff, get_user_model().USERNAME_FIELD), password=getattr(staff, get_user_model().USERNAME_FIELD)) response = self.client.post(add_url, post_data) # the user is logged in and the security check fails, so it should 403. self.assertEqual(response.status_code, 403) self.assertEqual(CMSPlugin.objects.count(), 0)
def _wrapped_view(request, gid, *args, **kwargs): if not canEdit(request, gid): url = reverse("maps:auth", kwargs={"gid":gid}) fwd = QueryDict('p=%s' % request.get_full_path()) return HttpResponseRedirect("%s?%s" % (url, fwd.urlencode())) return view(request, gid, *args, **kwargs)
def sso_logout(request): qs = QueryDict(None, mutable=True) qs['callback_url'] = request.build_absolute_uri(settings.SSO_LOGOUT_CALLBACK_PATH) logout_url = '{0}?{1}'.format(sso_hostname('/logout'), qs.urlencode(safe='/')) return HttpResponseRedirect(logout_url)
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 render_change_form(self, request, context, add=False, change=False, form_url='', obj=None): lang_code = self._language(request) lang = get_language_name(lang_code) available_languages = self.get_available_languages(obj) context.update({ 'title': '%s (%s)' % (context['title'], lang), 'current_is_translated': lang_code in available_languages, 'allow_deletion': len(available_languages) > 1, 'language_tabs': self.get_language_tabs(request, available_languages), 'base_template': self.get_change_form_base_template(), }) # Ensure form action url carries over tab language qs_language = request.GET.get('language') if qs_language: form_url = urlparse(form_url or request.get_full_path()) query = QueryDict(form_url.query, mutable=True) if 'language' not in query: query['language'] = qs_language form_url = form_url._replace(query=query.urlencode()).geturl() return super(TranslatableAdmin, self).render_change_form(request, context, add, change, form_url, obj)
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 test_edit(self): """ Test editing a *PAGE* plugin """ page, placeholder, superuser, staff = self.get_data() # create the plugin using a superuser plugin = add_plugin(placeholder, 'TextPlugin', 'en', body='body') plugin_data = { 'plugin_id': plugin.pk, 'body': 'newbody', } self.assertEqual(plugin.body, 'body') # check the body is as expected. # log the user out, try to edit the plugin self.client.logout() endpoint = self.get_change_plugin_uri(plugin) response = self.client.post(endpoint, plugin_data) # since the user is not logged in, they should be prompted to log in. self.assertEqual(response.status_code, 302) querystring = QueryDict('', mutable=True) querystring['next'] = endpoint expected_url = '/{lang}/admin/login/?{next}'.format( lang=settings.LANGUAGES[0][0], next=querystring.urlencode(safe='/') ) self.assertRedirects(response, expected_url) plugin = self.reload(plugin) self.assertEqual(plugin.body, 'body') # now log a staff user without permissions in and do the same as above. self.client.login(username=getattr(staff, get_user_model().USERNAME_FIELD), password=getattr(staff, get_user_model().USERNAME_FIELD)) response = self.client.post(endpoint, plugin_data) # the user is logged in and the security check fails, so it should 403. self.assertEqual(response.status_code, 403) plugin = self.reload(plugin) self.assertEqual(plugin.body, 'body')
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 test_mutable_copy(self): """A copy of a QueryDict is mutable.""" q = QueryDict().copy() with self.assertRaises(KeyError): q.__getitem__("foo") q["name"] = "john" self.assertEqual(q["name"], "john")
def test_delete_ph(self): page, placeholder, superuser, staff = self.get_data() plugin = add_plugin(placeholder, 'TextPlugin', 'en', body='body') plugin_data = { 'plugin_id': plugin.pk, } plugin = self.reload(plugin) self.assertEqual(plugin.body, 'body') endpoint = self.get_delete_plugin_uri(plugin, container=Example1) # log the user out and try to remove a plugin using PlaceholderAdmin self.client.logout() response = self.client.post(endpoint, plugin_data) # since the user is not logged in, they should be prompted to log in. self.assertEqual(response.status_code, 302) querystring = QueryDict('', mutable=True) querystring['next'] = endpoint expected_url = '/{lang}/admin/login/?{next}'.format( lang=settings.LANGUAGES[0][0], next=querystring.urlencode(safe='/') ) self.assertRedirects(response, expected_url) self.assertEqual(CMSPlugin.objects.count(), 1) # now log a staff user without permissions in and do the same as above. self.client.login(username=getattr(staff, get_user_model().USERNAME_FIELD), password=getattr(staff, get_user_model().USERNAME_FIELD)) response = self.client.post(endpoint, plugin_data) # the user is logged in and the security check fails, so it should 403. self.assertEqual(response.status_code, 403) self.assertEqual(CMSPlugin.objects.count(), 1)
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 _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 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 _parse_response(self, response): """Turn the PayPal response into a dict""" q = QueryDict(response, encoding='UTF-8').dict() tmp = {} for k,v in q.items(): tmp.update({k.lower(): v}) return tmp
def _get_initial_query_dict(self, qdict): if not qdict: qdict = QueryDict(None, mutable=True) elif isinstance(qdict, QueryDict): qdict = qdict.copy() elif isinstance(qdict, basestring): if qdict.startswith('?'): qdict = qdict[1:] qdict = QueryDict(qdict, mutable=True) else: # Accept any old dict or list of pairs. try: pairs = qdict.items() except: pairs = qdict qdict = QueryDict(None, mutable=True) # Enter each pair into QueryDict object: try: for k, v in pairs: # Convert values to unicode so that detecting # membership works for numbers. if isinstance(v, (list, tuple)): for e in v: qdict.appendlist(k,unicode(e)) else: qdict.appendlist(k, unicode(v)) except: # Wrong data structure, qdict remains empty. pass return qdict
def 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 test_expired_course(self): """ Ensure that a user accessing an expired course sees a redirect to the student dashboard, not a 404. """ CourseDurationLimitConfig.objects.create(enabled=True, enabled_as_of=datetime(2010, 1, 1)) course = CourseFactory.create(start=THREE_YEARS_AGO) url = course_home_url(course) for mode in [CourseMode.AUDIT, CourseMode.VERIFIED]: CourseModeFactory.create(course_id=course.id, mode_slug=mode) # assert that an if an expired audit user tries to access the course they are redirected to the dashboard audit_user = UserFactory(password=self.TEST_PASSWORD) self.client.login(username=audit_user.username, password=self.TEST_PASSWORD) audit_enrollment = CourseEnrollment.enroll(audit_user, course.id, mode=CourseMode.AUDIT) ScheduleFactory(start=THREE_YEARS_AGO, enrollment=audit_enrollment) response = self.client.get(url) expiration_date = strftime_localized(course.start + timedelta(weeks=4), 'SHORT_DATE') expected_params = QueryDict(mutable=True) course_name = CourseOverview.get_from_id(course.id).display_name_with_default expected_params['access_response_error'] = 'Access to {run} expired on {expiration_date}'.format( run=course_name, expiration_date=expiration_date ) expected_url = '{url}?{params}'.format( url=reverse('dashboard'), params=expected_params.urlencode() ) self.assertRedirects(response, expected_url)
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 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 get_url_found_user(user, page): get = QueryDict('', mutable=True) get['page'] = page return url + '?' + get.urlencode() + '#' + str(user.id)
def setUp(self): super(ClipboardPluginTest, self).setUp() UserModel = get_user_model() self.admin_user = UserModel.objects.get(username='******') # 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 3 Columns 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': 3}) 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) self.assertEqual(str(row_model), 'with 3 columns') plugin_list = [container_model, row_model] columns_qs = CascadeElement.objects.filter(parent_id=row_model.id) self.assertEqual(columns_qs.count(), 3) row_data = [] for column_model in columns_qs: self.assertIsInstance(column_model, CascadeElement) column_plugin = column_model.get_plugin_class_instance() self.assertIsInstance(column_plugin, BootstrapColumnPlugin) self.assertEqual(column_model.parent.id, row_model.id) self.assertEqual(str(column_model), 'default width: 4 units') plugin_list.append(column_model) row_data.append(['BootstrapColumnPlugin', {'glossary': column_model.glossary}, []]) # container_data = ['BootstrapRowPlugin', {'glossary': row_model.glossary}, row_data] # Render the Container Plugin with all of its children build_plugin_tree(plugin_list) html = self.get_html(container_model, self.get_request_context()) self.assertHTMLEqual(html, '<div class="container"><div class="row">' + '<div class="col-sm-4"></div><div class="col-sm-4"></div>' + '<div class="col-sm-4"></div>' + '</div></div>') # change data inside the first column column_model = columns_qs[0] delattr(column_model, '_inst') column_plugin = column_model.get_plugin_class_instance(self.admin_site) column_plugin.cms_plugin_instance = column_model post_data = QueryDict('', mutable=True) post_data.update({'sm-column-offset': 'col-sm-offset-1', 'sm-column-width': 'col-sm-3'}) ModelForm = column_plugin.get_form(self.request, column_model) form = ModelForm(post_data, None, instance=column_model) self.assertTrue(form.is_valid()) column_plugin.save_model(self.request, column_model, form, True) # change data inside the second column column_model = columns_qs[1] delattr(column_model, '_inst') column_plugin = column_model.get_plugin_class_instance(self.admin_site) column_plugin.cms_plugin_instance = column_model post_data = QueryDict('', mutable=True) post_data.update({'sm-responsive-utils': 'hidden-sm', 'sm-column-width': 'col-sm-4'}) ModelForm = column_plugin.get_form(self.request, column_model) form = ModelForm(post_data, None, instance=column_model) self.assertTrue(form.is_valid()) column_plugin.save_model(self.request, column_model, form, False) html = self.get_html(container_model, self.get_request_context()) self.assertHTMLEqual(html, '<div class="container"><div class="row">' + '<div class="col-sm-3 col-sm-offset-1"></div>' + '<div class="col-sm-4 hidden-sm"></div><div class="col-sm-4"></div>' + '</div></div>')
def do_oauth(accounts, apps, variant, settings, otp): from accounts.models import Account from idapi.models import IDApplication from django.core.urlresolvers import reverse from django.http import QueryDict import json def check_redirect(response, redirect_uri): assert response.status_code == 302 assert response.url.index(redirect_uri) == 0 from six.moves.urllib import parse params = QueryDict(parse.urlparse(response.url).query) assert params['state'] == 'mystate' return params noop = DummyContext() client = Client(secure=True) settings.TWO_FACTOR_AUTH = False member1 = accounts['member1'] if variant == 'inactive': member1.is_active = False member1.save(update_fields=['is_active']) url = reverse('authorize') app = apps['portal'] qd = QueryDict('', mutable=True) redirect_uri = app.redirect_uris data = dict( redirect_uri=redirect_uri, client_id=app.client_id, scope="unique member profile", state="mystate", response_type="code", ) if variant in ('redirect_uri1', 'scope1', 'client_id1'): data[variant[:-1]] = 'bad' normal = False else: normal = True qd.update(data) url += '?' + qd.urlencode() response = client.get(url) assert SESSION_KEY not in client.session if not normal: if variant == 'scope1': params = check_redirect(response, redirect_uri) assert params['error'] == 'invalid_scope' else: assert response.status_code == 400 return else: assert response.status_code == 200 data = response.context['form'].initial data.update(dict(username='******', password='******', allow='Authorize')) #,allow='Authorize' expect = raises(AssertionError) if variant in ('username', 'password'): data[variant] = 'bad' elif variant in ('redirect_uri2', 'scope2', 'client_id2'): data[variant[:-1]] = 'bad' if variant != 'redirect_uri2': expect = noop elif variant == 'inactive': pass else: expect = noop response = client.post(url, data, follow=False) with expect: params = check_redirect(response, redirect_uri) assert SESSION_KEY not in client.session if variant == 'scope2': assert params['error']=='invalid_scope' and \ params['error_description'] == 'scope bad is not permitted for this client' return elif variant == 'client_id2': assert params['error'] == 'invalid_client_id' return code = params['code'] if not expect is noop: return data = dict( code=code, client_id=app.client_id, client_secret=app.client_secret, grant_type='authorization_code', redirect_uri=redirect_uri, ) expect = raises(AssertionError) if variant[:-1] in ('redirect_uri', 'client_id') and variant[-1] == '3': data[variant[:-1]] = 'bad' elif variant in ('client_secret', 'code'): data['client_secret'] = 'bad' else: expect = noop headers = { 'Content-Type': 'application/x-www-form-urlencoded', 'Accept': 'application/json' } response = client.post(reverse('oauth2_provider:token'), data, **headers) with expect: assert response.status_code == 200 resp = json.loads(response.content.decode('utf-8')) assert resp['scope'] == qd['scope'] and resp['token_type'] == 'Bearer'
def do_login(accounts, variant, settings, otp): from accounts.models import Account from django.core import mail from django.core.urlresolvers import reverse from django.http import QueryDict from django_otp.plugins.otp_email.models import EmailDevice import re member1 = accounts['member1'] noop = DummyContext() client = Client(secure=True) device = 'django_otp.plugins.otp_email.models.EmailDevice/\d+' if variant == 'inactive': member1.is_active = False member1.save(update_fields=['is_active']) elif variant in ['opton', 'optoff']: settings.TWO_FACTOR_AUTH = 'optional' member1.two_factor_auth = variant == 'opton' member1.save(update_fields=['two_factor_auth']) elif otp: settings.TWO_FACTOR_AUTH = 'mandatory' else: settings.TWO_FACTOR_AUTH = False if otp: EmailDevice.objects.create(user=member1, name='email', confirmed=True) url = reverse('accounts:index') if variant == 'next': nexturl = reverse('accounts:profile') qd = QueryDict('', mutable=True) qd['next'] = nexturl url += '?' + qd.urlencode() else: nexturl = url if variant == 'partial': assert client.login(username='******', password='******') response = client.get(url, follow=True) check_response(response) assert 'form' in response.context if variant != 'partial': assert SESSION_KEY not in client.session data = dict(username='******', password='******') if variant in ('username', 'password'): data[variant] = 'bad' response = client.post(url, data, follow=True) if variant == 'optoff': check_response(response, url) assert SESSION_KEY in client.session return if variant in ['', 'next', 'token', 'opton']: expect = noop else: expect = raises(AssertionError) with expect: if otp: assert SESSION_KEY not in client.session check_response(response) assert 'form' in response.context device = re.search(device, response.content.decode("utf8")) assert device else: check_response(response, nexturl) assert SESSION_KEY in client.session assert 'form' not in response.context if not otp or not expect is noop: return else: assert SESSION_KEY in client.session device = re.search(device, response.content.decode("utf8")) assert device data = {} data['otp_device'] = device.group() data['otp_challenge'] = "Get challenge" response = client.post(url, data, follow=True) check_response(response) assert variant == 'partial' or SESSION_KEY not in client.session del data['otp_challenge'] assert len(mail.outbox) == 1 reply = mail.outbox[0] assert reply.to == [receiver] if variant == 'token': expect = raises(AssertionError) data['otp_token'] = 'bad' else: expect = noop data['otp_token'] = reply.body with expect: response = client.post(url, data, follow=True) check_response(response, nexturl) assert SESSION_KEY in client.session assert 'form' not in response.context
def _get_and_send_report(self, language, emails): from corehq.apps.reports.views import get_scheduled_report_response, render_full_report_notification with localize(language): title = ( _(DEFAULT_REPORT_NOTIF_SUBJECT) if self.email_subject == DEFAULT_REPORT_NOTIF_SUBJECT else self.email_subject ) attach_excel = getattr(self, 'attach_excel', False) try: content, excel_files = get_scheduled_report_response( self.owner, self.domain, self._id, attach_excel=attach_excel, send_only_active=True ) # Will be False if ALL the ReportConfigs in the ReportNotification # have a start_date in the future. if content is False: return for email in emails: body = render_full_report_notification(None, content, email, self).content send_html_email_async.delay( title, email, body, email_from=settings.DEFAULT_FROM_EMAIL, file_attachments=excel_files, smtp_exception_skip_list=LARGE_FILE_SIZE_ERROR_CODES) except Exception as er: notify_exception( None, message="Encountered error while generating report or sending email", details={ 'subject': title, 'recipients': str(emails), 'error': er, } ) if getattr(er, 'smtp_code', None) in LARGE_FILE_SIZE_ERROR_CODES or type(er) == ESError: # If the email doesn't work because it is too large to fit in the HTML body, # send it as an excel attachment, by creating a mock request with the right data. for report_config in self.configs: mock_request = HttpRequest() mock_request.couch_user = self.owner mock_request.user = self.owner.get_django_user() mock_request.domain = self.domain mock_request.couch_user.current_domain = self.domain mock_request.couch_user.language = self.language mock_request.method = 'GET' mock_request.bypass_two_factor = True mock_query_string_parts = [report_config.query_string, 'filterSet=true'] if report_config.is_configurable_report: mock_query_string_parts.append(urlencode(report_config.filters, True)) mock_query_string_parts.append(urlencode(report_config.get_date_range(), True)) mock_request.GET = QueryDict('&'.join(mock_query_string_parts)) date_range = report_config.get_date_range() start_date = datetime.strptime(date_range['startdate'], '%Y-%m-%d') end_date = datetime.strptime(date_range['enddate'], '%Y-%m-%d') datespan = DateSpan(start_date, end_date) request_data = vars(mock_request) request_data['couch_user'] = mock_request.couch_user.userID request_data['datespan'] = datespan full_request = {'request': request_data, 'domain': request_data['domain'], 'context': {}, 'request_params': json_request(request_data['GET'])} export_all_rows_task(report_config.report, full_request, emails)
def get_report_content(self, lang, attach_excel=False): """ Get the report's HTML content as rendered by the static view format. """ from corehq.apps.locations.middleware import LocationAccessMiddleware try: if self.report is None: return ReportContent( _("The report used to create this scheduled report is no" " longer available on CommCare HQ. Please delete this" " scheduled report and create a new one using an available" " report."), None, ) except Exception: pass if getattr(self.report, 'is_deprecated', False): return ReportContent( self.report.deprecation_email_message or _("[DEPRECATED] %s report has been deprecated and will stop working soon. " "Please update your saved reports email settings if needed." % self.report.name ), None, ) mock_request = HttpRequest() mock_request.couch_user = self.owner mock_request.user = self.owner.get_django_user() mock_request.domain = self.domain mock_request.couch_user.current_domain = self.domain mock_request.couch_user.language = lang mock_request.method = 'GET' mock_request.bypass_two_factor = True mock_query_string_parts = [self.query_string, 'filterSet=true'] if self.is_configurable_report: mock_query_string_parts.append(urlencode(self.filters, True)) mock_query_string_parts.append(urlencode(self.get_date_range(), True)) mock_request.GET = QueryDict('&'.join(mock_query_string_parts)) # Make sure the request gets processed by PRBAC Middleware CCHQPRBACMiddleware.apply_prbac(mock_request) LocationAccessMiddleware.apply_location_access(mock_request) try: dispatch_func = functools.partial(self._dispatcher.__class__.as_view(), mock_request, **self.view_kwargs) email_response = dispatch_func(render_as='email') if email_response.status_code == 302: return ReportContent( _( "We are sorry, but your saved report '%(config_name)s' " "is no longer accessible because the owner %(username)s " "is no longer active." ) % { 'config_name': self.name, 'username': self.owner.username }, None, ) try: content_json = json.loads(email_response.content) except ValueError: email_text = email_response.content else: email_text = content_json['report'] excel_attachment = dispatch_func(render_as='excel') if attach_excel else None return ReportContent(email_text, excel_attachment) except PermissionDenied: return ReportContent( _( "We are sorry, but your saved report '%(config_name)s' " "is no longer accessible because your subscription does " "not allow Custom Reporting. Please talk to your Project " "Administrator about enabling Custom Reports. If you " "want CommCare HQ to stop sending this message, please " "visit %(saved_reports_url)s to remove this " "Emailed Report." ) % { 'config_name': self.name, 'saved_reports_url': absolute_reverse( 'saved_reports', args=[mock_request.domain] ), }, None, ) except Http404: return ReportContent( _( "We are sorry, but your saved report '%(config_name)s' " "can not be generated since you do not have the correct permissions. " "Please talk to your Project Administrator about getting permissions for this" "report." ) % { 'config_name': self.name, }, None, ) except UnsupportedSavedReportError: return ReportContent( _( "We are sorry, but your saved report '%(config_name)s' " "is no longer available. If you think this is a mistake, please report an issue." ) % { 'config_name': self.name, }, None, )
def cats(request): try: if request.method == "POST" and request.FILES['catimage']: document = request.FILES['catimage'] cat_name = request.POST['cat_name_placeholder'] fs = FileSystemStorage() imagename = fs.save(document.name, document) imageurl = fs.url(imagename) previous_image = Cat.objects.filter(owner=request.user, cat_name=cat_name)[0].imagename file_remove = settings.MEDIA_ROOT + "/" + previous_image try: os.remove(file_remove) except: pass Cat.objects.filter(owner=request.user, cat_name=cat_name).update(imagename=imagename, imageurl=imageurl) except: pass try: if request.method == "POST" and request.FILES['recordimage']: document = request.FILES['recordimage'] record_id = request.POST['record_id_up'] fs = FileSystemStorage() imagename = fs.save(document.name, document) imageurl = fs.url(imagename) previous_image = MedicalRecord.objects.filter( pk=int(record_id))[0].imagename file_remove = settings.MEDIA_ROOT + "/" + previous_image try: os.remove(file_remove) except: pass MedicalRecord.objects.filter(pk=int(record_id)).update( imagename=imagename, imageurl=imageurl) except: pass try: if request.method == 'POST' and request.POST[ 'objective'] == "CREATE_CAT": cat_name = request.POST['cat_name'] gender = request.POST['gender'] birthday = request.POST['birthday'] cat_weight = request.POST['cat_weight'] cat_weight_unit = request.POST['cat_weight_unit'] cat_breed = request.POST['cat_breed'] Spayed_Neutered = request.POST['Spayed_Neutered'] microchip_number = request.POST['microchip_number'] insurance_provider = request.POST['insurance_provider'] insurance_policy_number = request.POST['insurance_policy_number'] clinic_name = request.POST['clinic_name'] if Spayed_Neutered == 'Yes': spayed = True elif Spayed_Neutered == 'No': spayed = False Cat.objects.create(owner=request.user, cat_name=cat_name, gender=gender, birthday=birthday, cat_weight=cat_weight, cat_weight_unit=cat_weight_unit, cat_breed=cat_breed, Spayed_Neutered=spayed, microchip_number=microchip_number, insurance_provider=insurance_provider, insurance_policy_number=insurance_policy_number, clinic_name=clinic_name, imagename="", imageurl="") except: pass try: if request.method == "PUT" and QueryDict( request.body).get('objective') == "EDIT_CAT": PUT = QueryDict(request.body) cat_name = PUT.get('cat_name') gender = PUT.get('gender') birthday = PUT.get('birthday') cat_photo = PUT.get('cat_photo') cat_weight = PUT.get('cat_weight') cat_weight_unit = PUT.get('cat_weight_unit') cat_breed = PUT.get('cat_breed') Spayed_Neutered = PUT.get('Spayed_Neutered') microchip_number = PUT.get('microchip_number') insurance_provider = PUT.get('insurance_provider') insurance_policy_number = PUT.get('insurance_policy_number') clinic_name = PUT.get('clinic_name') if Spayed_Neutered == 'Yes': spayed = True elif Spayed_Neutered == 'No': spayed = False if cat_weight is '': cat_weight = None if birthday == '': Cat.objects.filter( owner=request.user, cat_name=cat_name).update( gender=gender, cat_weight=cat_weight, cat_weight_unit=cat_weight_unit, cat_breed=cat_breed, Spayed_Neutered=spayed, microchip_number=microchip_number, insurance_provider=insurance_provider, insurance_policy_number=insurance_policy_number, clinic_name=clinic_name) else: Cat.objects.filter( owner=request.user, cat_name=cat_name).update( gender=gender, birthday=birthday, cat_weight=cat_weight, cat_weight_unit=cat_weight_unit, cat_breed=cat_breed, Spayed_Neutered=spayed, microchip_number=microchip_number, insurance_provider=insurance_provider, insurance_policy_number=insurance_policy_number, clinic_name=clinic_name) except: pass try: if request.method == "PUT" and QueryDict( request.body).get('objective') == "DELETE_CAT": cat_name = QueryDict(request.body).get('cat_name') Cat.objects.get(owner=request.user, cat_name=cat_name).delete() except: pass try: if request.method == 'POST' and request.POST[ 'objective'] == "CREATE_MEDICAL_RECORD": cat_model = request.POST['cat_model'] title = request.POST['title'] description = request.POST['description'] the_cat = Cat.objects.get(owner=request.user, cat_name=cat_model) MedicalRecord.objects.create(cat=the_cat, title=title, description=description, imagename="", imageurl="") except: pass try: if request.method == "PUT" and QueryDict( request.body).get('objective') == "DELETE_MEDICAL_RECORD": record_id = QueryDict(request.body).get('record_id') MedicalRecord.objects.get(pk=record_id).delete() except: pass try: if request.method == "PUT" and QueryDict( request.body).get('objective') == "CHANGE_MEDICAL_RECORD": PUT = QueryDict(request.body) record_id = PUT.get('record_id_change') new_title = PUT.get('title_change') new_description = PUT.get('description_change') MedicalRecord.objects.filter(pk=int(record_id)).update( title=new_title, description=new_description) except: pass user_cats = Cat.objects.filter(owner=request.user) cat_medical_records = MedicalRecord.objects.filter(cat__owner=request.user) context = { "owner_cats": user_cats, "cat_medical_records": cat_medical_records } return render(request, 'core/cats.html', context)
def test_immutable_get_with_default(self): q = QueryDict(str('')) self.assertEqual(q.get('foo', 'default'), 'default')
def test_update_from_querydict(self): """Regression test for #8278: QueryDict.update(QueryDict)""" x = QueryDict(str("a=1&a=2"), mutable=True) y = QueryDict(str("a=3&a=4")) x.update(y) self.assertEqual(x.getlist('a'), ['1', '2', '3', '4'])
def get_url_for_user(username): get = QueryDict('', mutable=True) get['user'] = username get['page'] = 1 return url + '?' + get.urlencode()
def test_mutable_delete(self): q = QueryDict(str('')).copy() q['name'] = 'john' del q['name'] self.assertFalse('name' in q)
def test_missing_key(self): q = QueryDict(str('')) self.assertRaises(KeyError, q.__getitem__, 'foo')
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_basic_mutable_operations(self): q = QueryDict(str('')).copy() q['name'] = 'john' self.assertEqual(q.get('foo', 'default'), 'default') self.assertEqual(q.get('name', 'default'), 'john') self.assertEqual(q.getlist('name'), ['john']) self.assertEqual(q.getlist('foo'), []) q.setlist('foo', ['bar', 'baz']) self.assertEqual(q.get('foo', 'default'), 'baz') self.assertEqual(q.getlist('foo'), ['bar', 'baz']) q.appendlist('foo', 'another') self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another']) self.assertEqual(q['foo'], 'another') if six.PY2: self.assertTrue(q.has_key('foo')) self.assertTrue('foo' in q) self.assertListEqual(sorted(list(six.iteritems(q))), [('foo', 'another'), ('name', 'john')]) self.assertListEqual(sorted(list(six.iterlists(q))), [('foo', ['bar', 'baz', 'another']), ('name', ['john'])]) self.assertListEqual(sorted(list(six.iterkeys(q))), ['foo', 'name']) self.assertListEqual(sorted(list(six.itervalues(q))), ['another', 'john']) q.update({'foo': 'hello'}) self.assertEqual(q['foo'], 'hello') self.assertEqual(q.get('foo', 'not available'), 'hello') self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another', 'hello']) self.assertEqual(q.pop('foo'), ['bar', 'baz', 'another', 'hello']) self.assertEqual(q.pop('foo', 'not there'), 'not there') self.assertEqual(q.get('foo', 'not there'), 'not there') self.assertEqual(q.setdefault('foo', 'bar'), 'bar') self.assertEqual(q['foo'], 'bar') self.assertEqual(q.getlist('foo'), ['bar']) self.assertIn(q.urlencode(), ['foo=bar&name=john', 'name=john&foo=bar']) q.clear() self.assertEqual(len(q), 0)
def test_missing_key(self): q = QueryDict() with self.assertRaises(KeyError): q.__getitem__('foo')
def test_mutable_copy(self): """A copy of a QueryDict is mutable.""" q = QueryDict(str('')).copy() self.assertRaises(KeyError, q.__getitem__, "foo") q['name'] = 'john' self.assertEqual(q['name'], 'john')
def test_fromkeys_noniterable(self): with self.assertRaises(TypeError): QueryDict.fromkeys(0)
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_duplicates_in_fromkeys_iterable(self): self.assertEqual(QueryDict.fromkeys('xyzzy'), QueryDict('x&y&z&z&y'))
def test_create_with_no_args(self): self.assertEqual(QueryDict(), QueryDict(str('')))
def test_fromkeys_is_immutable_by_default(self): # Match behavior of __init__() which is also immutable by default. q = QueryDict.fromkeys(['key1', 'key2', 'key3']) with self.assertRaisesMessage(AttributeError, 'This QueryDict instance is immutable'): q['key4'] = 'nope'
def test_fromkeys_empty_iterable(self): self.assertEqual(QueryDict.fromkeys([]), QueryDict(''))
def test_querydict_fromkeys(self): self.assertEqual(QueryDict.fromkeys(['key1', 'key2', 'key3']), QueryDict('key1&key2&key3'))
def test_fromkeys_mutable_override(self): q = QueryDict.fromkeys(['key1', 'key2', 'key3'], mutable=True) q['key4'] = 'yep' self.assertEqual(q, QueryDict('key1&key2&key3&key4=yep'))
def test_mutable_delete(self): q = QueryDict(mutable=True) q['name'] = 'john' del q['name'] self.assertNotIn('name', q)
def test_fromkeys_with_nonempty_value(self): self.assertEqual( QueryDict.fromkeys(['key1', 'key2', 'key3'], value='val'), QueryDict('key1=val&key2=val&key3=val'))
def handleCourseRequests(request): hash_id = request.user.hash_id if request.method == "GET": data = {} # Propogate memories to return to frontend for courseRequest in CourseRequest.objects.filter(hash_id = hash_id): data[courseRequest.id] = {"courses": courseRequest.courses, "topPriority": courseRequest.topPriority, "sport": courseRequest.sport, "musicLesson": courseRequest.musicLesson, "comments": courseRequest.comments} # Return data to frontend return JsonResponse(data, status=200) if request.method == "POST": # Decode request body content content = QueryDict(request.body.decode('utf-8')).dict() # Determine a string representation of the term date = datetime.date() if 3 <= date.month <= 9: term = "Fall '" + str(date.year%100) elif 10 <= date.month <= 12: term = "Winter '" + str((date.year + 1)%100) else: term = "Spring '" + str(date.year%100) try: coursesString = content["courses"] # should be an array of the courses' IDs courses = [] num = "" count = 0 # parse string array, will look like "[[-1, 2, 3], [4, 5, 6]]" tempCourses = [] for char in coursesString: if char == '[': count += 1 if char == ']': courses.append(tempCourses) tempCourses = [] count -= 1 elif char.isdigit() or char == "-": num += char elif char == ',' and count > 1: tempCourses.append(int(num)) num = "" sixthCourse = int(content["sixthCourse"]) topPriority = int(content["topPriority"]) sport = content["sport"] # should be the sport's ID mL = content["musicLesson"] # should be a dict in the proper musiclesson format comments = content["comments"] except: return JsonResponse({'status':'false', 'message':"Unable to parse dictionary of params"}, status=401) try: musicLesson = MusicLession(instrument=mL["instrument"], teacher=mL["teacher"],length=mL["length"]) musicLesson.save() except: musicLesson = -1 return JsonResponse({'status':'false', 'message':"Unable to process music lesson"}, status=401) # Create a CourseRequest object and save its reference to access id try: courseRequest = CourseRequest(hash_id = hash_id, term = term, courses = courses, topPriority = topPriority, sport = sport, musicLesson = musicLesson.id, comments = comments) courseRequest.save() except: return JsonResponse({'status':'false', 'message':"Unable to save course request"}, status=401) returning = JsonResponse({'status':'true', 'message':"Your course request has been POSTed"}, status=200)
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 response_dict(self): """ Returns a (MultiValueDict) dictionary containing all the parameters returned in the PayPal response. """ # Undo the urlencode done in init return QueryDict(self.response)
def authenticate(request: WSGIRequest) -> HttpResponse: request.session["token"] = QueryDict(request.body).get("token") return HttpResponse(status=http.HTTPStatus.OK)