def process_request(self, request): schema = "http" if not request.is_secure() else "https" path = request.get_full_path() domain_may_with_port = request.META["HTTP_HOST"] domain_seprated = domain_may_with_port.split(":") port = None if len(domain_seprated) > 1: domain = domain_seprated[0] port = domain_seprated[1] else: domain = domain_may_with_port pieces = domain.split(".") subdomain = pieces[0] default_domain = Site.objects.get(id=settings.SITE_ID).domain redirect_path = "{0}://{1}{2}".format(schema, default_domain+":"+port if port else default_domain, path) if domain in {default_domain, "localhost", "127.0.0.1"}: return None try: resolve(path) except Resolver404: try: # The slashes are not being appended before getting here resolve(u"{0}/".format(path)) except Resolver404: return redirect(redirect_path) try: user = User.objects.get(username=subdomain) except User.DoesNotExist: return redirect(redirect_path) request.whom = user return None
def test_404_tried_urls_have_names(self): """ Verifies that the list of URLs that come back from a Resolver404 exception contains a list in the right format for printing out in the DEBUG 404 page with both the patterns and URL names, if available. """ urls = 'urlpatterns_reverse.named_urls' # this list matches the expected URL types and names returned when # you try to resolve a non-existent URL in the first level of included # URLs in named_urls.py (e.g., '/included/non-existent-url') url_types_names = [ [{'type': RegexURLPattern, 'name': 'named-url1'}], [{'type': RegexURLPattern, 'name': 'named-url2'}], [{'type': RegexURLPattern, 'name': None}], [{'type': RegexURLResolver}, {'type': RegexURLPattern, 'name': 'named-url3'}], [{'type': RegexURLResolver}, {'type': RegexURLPattern, 'name': 'named-url4'}], [{'type': RegexURLResolver}, {'type': RegexURLPattern, 'name': None}], [{'type': RegexURLResolver}, {'type': RegexURLResolver}], ] try: resolve('/included/non-existent-url', urlconf=urls) self.fail('resolve did not raise a 404') except Resolver404 as e: # make sure we at least matched the root ('/') url resolver: self.assertTrue('tried' in e.args[0]) tried = e.args[0]['tried'] self.assertEqual(len(e.args[0]['tried']), len(url_types_names), 'Wrong number of tried URLs returned. Expected %s, got %s.' % (len(url_types_names), len(e.args[0]['tried']))) for tried, expected in zip(e.args[0]['tried'], url_types_names): for t, e in zip(tried, expected): self.assertIsInstance(t, e['type']), str('%s is not an instance of %s') % (t, e['type']) if 'name' in e: if not e['name']: self.assertTrue(t.name is None, 'Expected no URL name but found %s.' % t.name) else: self.assertEqual(t.name, e['name'], 'Wrong URL name. Expected "%s", got "%s".' % (e['name'], t.name))
def test_api_urls_resolve_correctly(self): found = resolve(u'/actionInventoryItems/1') self.assertEqual(found.func, actionInventoryItems) found = resolve(u'/inventoryItems/') self.assertEqual(found.func, inventoryItemList) found = resolve(u'/inventoryItems/1') self.assertEqual(found.func, inventoryItemDetail)
def post_fork(server, worker): import mimetypes mimetypes.init() # hacky way to address gunicorn gevent requests hitting django too early before urls are loaded # see: https://github.com/benoitc/gunicorn/issues/527#issuecomment-19601046 from django.core.urlresolvers import resolve resolve('/')
def test_password_reset(self): """ Tests the forgotten/reset password workflow. """ c = Client() resp = c.get(reverse('password_reset')) self.assertTrue(resp.status_code, 200) resp = c.post(reverse('password_reset'), data={'email': '*****@*****.**'}) self.assertEqual(resp.status_code, 302) self.assertEqual(len(mail.outbox), 1) token = resp.context[0]['token'] uid = resp.context[0]['uid'] # Grab the token and uidb64 so that we can hit the reset url resp = c.get(reverse('password_reset_confirm', kwargs={'token': token, 'uidb64': uid})) self.assertEqual(resp.status_code, 200) self.assertTrue(resp.template_name.endswith('password_reset_confirm.html')) resp = c.post(reverse('password_reset_confirm', kwargs={'token': token, 'uidb64': uid}), {'new_password1': 'mynewpassword', 'new_password2': 'mynewpassword'}) self.assertEqual(resp.status_code, 302) self.assertEqual(resolve(urlsplit(resp.url).path).url_name, 'password_reset_complete') resp = c.post(reverse('login'), {'username': '******', 'password': '******'}) # User is returned to the login page on error vs redirected by default self.assertEqual(resp.status_code, 302) self.assertNotEqual(resolve(urlsplit(resp.url).path).url_name, 'login')
def is_valid_path(request, path): urlconf = getattr(request, 'urlconf', None) try: urlresolvers.resolve(path, urlconf) return True except urlresolvers.Resolver404: return False
def test_css_same_name_different_path_include_boths(self): self._signal_has_been_called = False template = Template(''' {% load medialint_tags %} {% cssjoin "/media/css/reset.css" %} <link rel="stylesheet" href="/media/css/fake_joined.css" /> <link rel="stylesheet" href="/media/css2/fake_joined.css" /> {% endcssjoin %} ''') view_1, args_1, kwargs_1 = resolve('/media/css/fake_joined.css') view_2, args_2, kwargs_2 = resolve('/media/css2/fake_joined.css') content_1 = view_1(request=HttpRequest(), *args_1, **kwargs_1) content_2 = view_2(request=HttpRequest(), *args_2, **kwargs_2) content_expected = "".join([content_1.content, content_2.content]) def on_render(sender, **kw): self.assertEquals( kw['joined_content'], '.teste{border:solid 1px}.teste2{font:12px}' ) self._signal_has_been_called = True css_joined.connect(on_render) c = RequestContext({}) got = template.render(c).strip() expected = '''<link rel="stylesheet" href="/media/css/reset.css" />''' assert self._signal_has_been_called self.assertEquals(got, expected) css_joined.disconnect(on_render)
def process_request(self, request): referer_url = request.META.get('HTTP_REFERER') return_to_list_url = request.session.get('return_to_list_url') """ There's no point doing anything unless we have a referer_url, and return_to_list_url has been set """ if referer_url and return_to_list_url: try: resolver_match = resolve(request.path) if resolver_match.url_name in ['wagtailadmin_explore', 'wagtailsnippets_list']: referer_match = resolve(urlparse(referer_url).path) if referer_match.url_name in ( 'wagtailadmin_pages_create', 'wagtailadmin_pages_edit', 'wagtailadmin_pages_delete', 'wagtailadmin_pages_unpublish', 'wagtailsnippets_create', 'wagtailsnippets_edit', 'wagtailsnippets_delete', ): return HttpResponseRedirect(return_to_list_url) except Resolver404: pass return None
def __call__(self, environ, start_response): """ A WSGI call that provides switching capabilities between Django and web.py. It supports a header named 'WebFrameworkSwitch' which can be set to 'django' or 'webpy'. It will check this header first and route the request accordingly. The default behavior is to inspect if Django supports the requested URL. If it does, the request is routed to Django. If it is not, it is routed to the web.py call stack. """ # First check if the client is specifying the framework to use if 'HTTP_WEBFRAMEWORKSWITCH' in environ: if environ['HTTP_WEBFRAMEWORKSWITCH'] == 'django': return self._handle_with_django(environ, start_response) else: return self._handle_with_webpy(environ, start_response) # /tasks/search/ is blocked, so we need that url to go to webpy even though it matches # /tasks/<task_id>/ in django urls. if environ['PATH_INFO'] == '/v2/tasks/search/': return self._handle_with_webpy(environ, start_response) # This is the start of the default behavior try: resolve(environ['PATH_INFO'], urlconf='pulp.server.webservices.urls') except Resolver404: pass else: return self._handle_with_django(environ, start_response) return self._handle_with_webpy(environ, start_response)
def process_response(self, request, response): # Our process_request may not have been called if another middleware's # process_request short circuited, so check first. This could still # leak if another middleware's process_response raises an exception. if response.status_code == 404 and not request.user.is_authenticated(): # This 404 response might be because we never installed the # login_required urlpatterns. To be sure, try to resolve # the request's URL using just UrlconfIncludePages. If it # resolves, we know we need to redirect_to_login instead of # 404ing. try: # Only do something if it's a resolver 404 (the path doesn't # resolve originally). BBB In django >= 1.5 we can use # request.resolver_match. urlresolvers.resolve(request.get_full_path(), request.urlconf) except urlresolvers.Resolver404: empty_urlconf = imp.new_module('urlconf') empty_urlconf.urlpatterns = patterns('') urlconf = self.get_urlconf(empty_urlconf, self.get_pages(logged_in=True)) try: urlresolvers.resolve(request.get_full_path(), urlconf) except urlresolvers.Resolver404: pass else: from django.contrib.auth.views import redirect_to_login response = redirect_to_login(request.get_full_path()) finally: urlresolvers.clear_url_caches() if hasattr(request, 'urlconf'): urlresolvers.clear_url_caches() if hasattr(request, '_patch_urlconf_middleware_urlconf'): urlresolvers.clear_url_caches() return response
def _cart_id(request): cart_id_pref = '' try: cart_id_pref = resolve(request.GET['cur_path']).kwargs['pos_id'] except: pass if cart_id_pref == '': try: cart_id_pref = resolve(request.POST['cur_path']).kwargs['pos_id'] except: pass if cart_id_pref == '': try: cart_id_pref = resolve(json.loads(request.POST)['cur_path']).kwargs['pos_id'] except: pass if request.user.is_authenticated(): # if request.session.get(CART_ID_SESSION_KEY,'') == '': request.session[CART_ID_SESSION_KEY] = cart_id_pref + '_' + request.user.username + '_' + str(request.user.id) else: if request.session.get(CART_ID_SESSION_KEY, '') == '': request.session[CART_ID_SESSION_KEY] = _generate_cart_id() return cart_id_pref + '_' + request.session[CART_ID_SESSION_KEY] return request.session[CART_ID_SESSION_KEY]
def test_middleware_stats(self): from django.core.urlresolvers import reverse, resolve, Resolver404 from datetime import date, timedelta analytics = self.overall_analytics yesterday = date.today() - timedelta(days=1) tomorrow = date.today() + timedelta(days=1) # url = reverse('resource', args=['2']) # print url # /depot/resource/2/ try: match = resolve('/depotxx/resource/2/') except Resolver404: pass match = resolve('/depot/resource/2/') # Print the URL pattern that matches the URL # print match.url_name, match.args, match.kwargs oid = str(self.resource1.id) url = reverse('resource', args=[self.resource1.id]) ip = '127.0.0.9' agent1 = 'engine_tests' agent2 = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2' result = self.client.get(url, HTTP_USER_AGENT=agent1, REMOTE_ADDR=ip) result = self.client.get(url, HTTP_USER_AGENT=agent1, REMOTE_ADDR=ip) result = self.client.get(url, HTTP_USER_AGENT=agent2, REMOTE_ADDR=ip) self.assertEqual(result.status_code, 200) # 'Unknown Browser' not logged self.assertEqual(analytics.sum_hash('HTTP_USER_AGENT', yesterday, tomorrow), [('Safari 5', 1)])
def set_language(request): next = request.REQUEST.get('next', '/') if request.method == 'GET': context = RequestContext(request, {'next': quote(next)}) return render_to_response('select_language.html', context) if request.method != 'POST': raise Http404() if not next.startswith('/'): next = '/' else: try: resolve(unquote(next)) except Resolver404: next = '/' lang = request.POST.get('language') response = HttpResponseRedirect(next) if lang not in settings.SUPPORTED_LANGUAGES: raise Http404('Unsupported language') if request.user.is_authenticated(): account = request.user account.preferredlanguage = lang account.save() set_language_info(request, response, lang) return response
def url_exists(url, local=False): """ Check if URL exists. :param str url: :param bool local: :return bool: """ if not local: try: r = requests.head(url) return r.status_code == requests.codes.ok except (ConnectionError, ConnectTimeout, ReadTimeout, SSLError, ProxyError, RetryError) as err: return False else: if 'localeurl' in settings.INSTALLED_APPS and callable(strip_path): url = strip_path(url)[1] try: resolve(url) return True except Resolver404 as err: return False
def is_valid_url(url): from django.core.urlresolvers import resolve try: resolve(url) return True except: return False
def views(self): # Check login view url = reverse('login') if url != settings.LOGIN_URL: self.stderr.write('WARNING: login URL not equal to ' 'settings.LOGIN_URL') func, args, kwargs = resolve(url) if func != login: self.stderr.write('WARNING: login view isn\'t the ' 'django_auth_policy.views.login view') if 'authentication_form' in kwargs: if not issubclass(kwargs['authentication_form'], StrictAuthenticationForm): self.stderr.write('WARNING: login view doesn\'t use ' 'the StrictAuthenticationForm') else: self.stderr.write('WARNING: could not check if login view uses ' 'the StrictAuthenticationForm') # Check password change view url = reverse(getattr(settings, 'ENFORCED_PASSWORD_CHANGE_VIEW_NAME', 'password_change')) func, args, kwargs = resolve(url) if 'password_change_form' in kwargs: if not issubclass(kwargs['password_change_form'], StrictPasswordChangeForm): self.stderr.write('WARNING: password_change view doesn\'t use ' 'the StrictPasswordChangeForm') else: self.stderr.write('WARNING: could not check if password_change ' 'view uses the StrictAuthenticationForm')
def post(self, request, id=None, **kw): obj = None if id: obj = get_object_or_404(self.model, id=id) form = self.form(request.POST, instance=obj) if not self.redirect_to: _redirect_to = resolve(request.path_info).url_name else: form = self.form(request.POST) _redirect_to = self.redirect_to if form.is_valid(): obj = form.save() messages.add_message( request, messages.SUCCESS, form.messages.get("save") ) return redirect(_redirect_to, id=obj.id) else: return { 'form': form, 'breadcrumb_data': { 'previous_label': self.breadcrumbs["previous_label"], 'previous_viewname': self.breadcrumbs["previous_view"], 'current_label': obj or "Adicionar", 'current_viewname': resolve(request.path_info).url_name, }, }
def _is_excluded_path(self, actual_path): paths = settings.PASSWORD_CHANGE_MIDDLEWARE_EXCLUDED_PATHS path = r'^%s$' % self.url paths.append(path) media_url = settings.MEDIA_URL if media_url: paths.append(r'^%s?' % media_url) static_url = settings.STATIC_URL if static_url: paths.append(r'^%s?' % static_url) if settings.PASSWORD_CHANGE_MIDDLEWARE_ALLOW_LOGOUT: try: logout_url = reverse('logout') except NoReverseMatch: pass else: paths.append(r'^%s$' % logout_url) try: logout_url = u'/admin/logout/' resolve(logout_url) except Resolver404: pass else: paths.append(r'^%s$' % logout_url) for path in paths: if re.match(path, actual_path): return True return False
def test_resolve_urls(self): url_resolve = resolve('/') self.assertEqual(url_resolve.view_name, 'home') url_resolve = resolve('/2014/01/Esto-es-un-titulo-111/') self.assertEqual(url_resolve.view_name, 'detail')
def check_table(self, error_handler=_error): """Find and report Addon table inconsistencies. :keyword error_handler: A callable that takes one argument, an Addon row. This is called when a row has a problem. :type error_handler: Callable :return: The total number of apps in the table (taken after checking the table), and the bad rows that were found. The error_handler was called on each bad row. :rtype: (int, list of str) """ from django.core.urlresolvers import Resolver404 result = [] # For every Addon row... for row in self.model.objects.all(): # Create the add-on's root URL. The url_root column should be only # the root without leading or trailing slashes, or an "http://", # but we'll be liberal in what we accept. url = row.url_root.replace("http://", '').replace("https://", '') url = '/' + url.strip('/') + '/' # Test this url root try: resolve(url) except Resolver404: # This URL root doesn't exist. Process the error and iterate. result.append(str(row)) error_handler(row) return (self.model.objects.count(), result)
def get_sender_path(extra_context, sender): ''' sender_path: a path to the sender. If not specified in extra_context then a url will be generated automatically (/content_type/sender.id/) if your url's are the same as your model names this should work. If the website backend is present then the sender_url will pass through the view_sender view and mark the notice as seen. *If specified in extra_context, provide just the path and it will be converted to the proper url automatically. NOTIFICATION_SENDER_URLS:provide a dictionary of sender to url overides. IE: if your content sender content_type user is located at path '/profie/' then specify {'user':'******'} sender_url will generate a link to this path when the word "user" or the translation is found in your notification description. ''' sender_path = extra_context.get('sender_path', False) if not sender_path: #generate a path if not supplied in extra_conext ctype_translations = getattr(settings, 'NOTIFICATION_CONTENT_TYPE_TRANSLATIONS', {}) try: ctype = ContentType.objects.get_for_model(sender) if ctype in ctype_translations: ctype = ctype_translations['ctype'] sender_path = '/'+str(ctype)+'/'+str(sender.id)+'/' resolve(sender_path) except: sender_path = "" return sender_path
def on_not_logged_in(self, request, url, error=None): """Called whenever the user is not logged in.""" if request.is_ajax(): logger.debug('Request is Ajax, returning HTTP 403.') return HttpResponseForbidden() try: for lookup_view in settings.LOGIN_REDIRECT["redirect"]: try: if url == reverse(lookup_view): url = parse_url(settings.LOGIN_REDIRECT) except NoReverseMatch: try: resolve(lookup_view) if url == lookup_view: url = parse_url(settings.LOGIN_REDIRECT) except Http404: logger.error('Cannot resolve url %s' % lookup_view) except KeyError: pass except Exception: logger.error( 'Error while redirection on not logged in.', exc_info=True) args = {'url': url} logger.debug( 'Request is not Ajax, redirecting to %s?%s' % (self.login_url, urlencode(args))) return HttpResponseRedirect( '%s?%s' % (self.login_url, urlencode(args)))
def test_process_cancel_view(self): act = ActionsTestFlow.start.run() view = views.CancelProcessView.as_view() # get request = RequestFactory().get('/cancel/') request.user = User(username='******', is_superuser=True) request.resolver_match = resolve('/test/') response = view(request, flow_class=ActionsTestFlow, process_pk=act.process.pk) self.assertEqual(response.status_code, 200) self.assertEqual(response.template_name, ('tests/test_views_actions/actionstest/process_cancel.html', 'viewflow/flow/process_cancel.html')) self.assertEqual(response.context_data['process'], act.process) self.assertEqual(len(response.context_data['active_tasks']), 1) self.assertEqual(response.context_data['uncancelable_tasks'], []) # post request = RequestFactory().post('/cancel/', {'_cancel_process': 1}) request.user = User(username='******', is_superuser=True) request.resolver_match = resolve('/test/') response = view(request, flow_class=ActionsTestFlow, process_pk=act.process.pk) act.process.refresh_from_db() self.assertEqual(response.status_code, 302) self.assertEqual(act.process.status, STATUS.CANCELED) canceled_task = act.process.get_task(ActionsTestFlow.task, status=[STATUS.CANCELED]) self.assertIsNotNone(canceled_task.finished)
def process_request(self, request): """ If lang is found in Get, changes language to selected one :param request: django request :return: if lang found, redirects back to view but without get params """ if 'lang' in request.GET: # Get selected language and current view language = request.GET.get('lang', False) current_site = get_current_site() # Checks that selected language code is supported possible_languages = settings.LANGUAGES for possible_lang in possible_languages: if language in possible_lang: # Change active language request.session[translation.LANGUAGE_SESSION_KEY] = language request.COOKIES[settings.LANGUAGE_COOKIE_NAME] = language translation.activate(language) break try: resolve(request.path) return redirect('/{0}{1}'.format(current_site.slug, request.path)) except Resolver404: return redirect('/{0}'.format(current_site.slug))
def unserialize(self, value): from django.core.urlresolvers import resolve form_field = self.get_form_field() pks = [] if isinstance(value, list): for pk in value: try: pks.append(int(pk)) except ValueError: try: func, args, kwargs = resolve(pk) pks.append(kwargs["pks"]) except: raise ValidationError(form_field.error_messages["invalid_choice"]) else: try: pks = [int(value)] except ValueError: try: func, args, kwargs = resolve(value) pks = [kwargs["pks"]] except: raise ValidationError(form_field.error_messages["invalid_choice"]) obj = form_field.clean(pks) return obj
def clean(self): data = self.cleaned_data if not data.get('template', None) and data.get('url', None): try: resolve(data['url']) except Resolver404, e: self._errors['template'] = self.error_class(['This field is required for admin-created pages.'])
def test_submit(self): """ Testing submit """ item = create_content_item(ContactFormItem, pk=2, form_style='default', email_to='*****@*****.**', success_message='Thanks!') # Submit, but not via the form button request = get_dummy_request('post', data={}) request.resolver_match = resolve('/admin/') output = render_content_items([item], request=request) self.assertTrue(output.html.count('name="contact2_submit"'), 1) # still displays form self.assertTrue('error' not in output.html) # no errors! # Submit, but not via the form button request = get_dummy_request('post', data={ 'contact2-name': "Test", 'contact2-email': '*****@*****.**', 'contact2-phone_number': '', 'contact2-subject': 'Test!', 'contact2-message': "Hello!", 'contact2_submit': "Submit", }) request.resolver_match = resolve('/admin/') self.assertRaises(HttpRedirectRequest, lambda: render_content_items([item], request=request)) self.assertTrue(request.session['contact2_submitted'])
def test_task_cancel_view(self): act = ActionsTestFlow.start.run() view = views.CancelTaskView.as_view() task = act.process.get_task(ActionsTestFlow.task, status=[STATUS.NEW]) # get request = RequestFactory().get('/cancel/') request.user = User(username='******', is_superuser=True) request.resolver_match = resolve('/test/') response = view( request, flow_class=ActionsTestFlow, flow_task=ActionsTestFlow.task, process_pk=act.process.pk, task_pk=task.pk) self.assertEqual(response.status_code, 200) self.assertEqual(response.template_name, ('tests/test_views_actions/actionstest/task_cancel.html', 'tests/test_views_actions/actionstest/task_cancel.html', 'viewflow/flow/task_cancel.html', 'viewflow/flow/task_action.html')) self.assertEqual(response.context_data['activation'].process, act.process) # post request = RequestFactory().post('/cancel/', {'run_action': 1}) request.user = User(username='******', is_superuser=True) request.resolver_match = resolve('/test/') response = view( request, flow_class=ActionsTestFlow, flow_task=ActionsTestFlow.start, process_pk=act.process.pk, task_pk=task.pk) task.refresh_from_db() self.assertEqual(response.status_code, 302) self.assertEqual(task.status, STATUS.CANCELED) self.assertIsNotNone(task.finished)
def process_request(self, request): super(UserSubdomainMiddleware, self).process_request(request) if request.subdomain is not None: try: user = User.objects.get(username__iexact=request.subdomain, is_active=True) request.subdomain_user = user prefix = "/%s/%s" % (urls.get("SHOW_PROFILE"), request.subdomain) try: resolve(prefix + request.path_info) request.path_info = prefix + request.path_info except Http404, e: if not any(request.path_info.startswith(p) for p in VALID_SUBDOMAIN_PREFIXES): # dirty hack for old blog.filmaster.pl links if request.subdomain == "blog": match = re.match("/(?P<permalink>[\w\-_]+)/$", request.path_info) if match: return HttpResponseRedirect( reverse("show_article", args=[request.subdomain, match.group(1)]).replace( prefix, "" ) ) raise except User.DoesNotExist: logger.debug("User [ %s ] Does not exists ..." % request.subdomain)
def checkout(self): # add address information post_data = { 'ship-name': 'John Doe', 'ship-address': 'Rosestreet', 'ship-address2': '', 'ship-zip_code': '01234', 'ship-city': 'Toledeo', 'ship-state': 'Ohio', 'ship-country': self.country_usa.pk, 'bill-name': 'John Doe', 'bill-address': 'Rosestreet', 'bill-address2': '', 'bill-zip_code': '01234', 'bill-city': 'Toledeo', 'bill-state': 'Ohio', 'bill-country': self.country_usa.pk, 'shipping_method': 'flat', 'payment_method': 'viveum', } response = self.client.post(reverse('checkout_selection'), post_data, follow=True) urlobj = urlparse.urlparse(response.redirect_chain[0][0]) self.assertEqual(resolve(urlobj.path).url_name, 'checkout_shipping') urlobj = urlparse.urlparse(response.redirect_chain[1][0]) self.assertEqual(resolve(urlobj.path).url_name, 'flat') self.order = self.viveum_backend.shop.get_order(self.request)
def set_value(self, value): """ Sets the parameter value, converting into the appropriate data type. Deals with date/time strings that are timezone naive or aware, based on the USE_TZ setting. :param basestring value: a string (or string-like) repr of the value :raises SuspiciousOperation: """ if self.name.isNumeric(): self.numerical_value = float(value) elif self.name.isDateTime(): # We convert the value string into datetime object. # dateutil.parser detects and converts many date formats and is # quite permissive in what it accepts (form validation and API # input validation happens elsewhere and may be less permissive) datevalue = dateutil.parser.parse(value) if settings.USE_TZ and is_naive(datevalue): datevalue = make_aware(datevalue, LOCAL_TZ) elif not settings.USE_TZ and is_aware(datevalue): datevalue = make_naive(datevalue, LOCAL_TZ) self.datetime_value = datevalue elif self.name.isLink(): # Always store the raw value as a string, even if setting # the GenericForeignKey via link_id/link_ct if str(value) == '' or value is None: return self.string_value = unicode(value) try: # We detect experiment or dataset view URLs # (eg, /experiment/view/12345/ or /api/v1/dataset/456) # and extract values to populate link_ct and link_id. This # covers two common cases, allowing LINK Parameters to be # properly created via the REST API. match = resolve(value) if match.view_name == u'api_dispatch_detail': model_name = match.kwargs.get(u'resource_name', None) if model_name not in ('experiment', 'dataset'): model_name, pk = None, None else: pk = match.kwargs.get('pk', None) elif match.view_name.endswith('view_experiment'): model_name = 'experiment' pk = match.kwargs.get('experiment_id') elif match.view_name.endswith('view_dataset'): model_name = 'dataset' pk = match.kwargs.get('dataset_id') else: model_name, pk = None, None if pk is not None and model_name is not None: self.link_id = pk self.link_ct = ContentType.objects.get( app_label='tardis_portal', model=model_name.lower()) except (ValueError, IndexError, Resolver404): # If we were unable to successfully match the url to model # instance, return an error. For any URL the URL Parameter # type should be used. raise SuspiciousOperation('Link parameter could not be set ' 'from string: %s' % str(value)) else: self.string_value = unicode(value)
def test_url_resolves_to_manager_assistant_form(self): found = resolve(reverse('manager_assistant_form_view', args=[1])) self.assertEqual(found.func, assistant_form_view)
def test_url_resolves_to_manager_reviews_view(self): found = resolve(reverse('manager_reviews_view', args=[1])) self.assertEqual(found.func, reviews_view)
def test_url_resolves_to_manager_message_send_to_reviewers(self): found = resolve(reverse('send_message_to_reviewers')) self.assertEqual(found.func, send_message_to_reviewers)
def test_url_resolves_to_manager_messages_view(self): found = resolve('/assistants/manager/messages/history/') self.assertEqual(found.func, show_history)
def test_root_url_resolves_to_home_page_view(self): found = resolve('/') self.assertEqual(found.func, home_page)
def get_object(self, queryset=None) -> ItemCategory: url = resolve(self.request.path_info) try: return self.request.event.categories.get(id=url.kwargs['category']) except ItemCategory.DoesNotExist: raise Http404(_("The requested product category does not exist."))
def setUp(self): self.create_api_user() self.url = reverse('accounts.profile') self.cls = resolve(self.url).func.cls super(TestProfileView, self).setUp()
def get_context_data(self, **kwargs): context = super(MaintenanceStatsView, self).get_context_data(**kwargs) context['this_url_name'] = resolve(self.request.path_info).url_name self.maintplan_name = self.kwargs['maintplan_name'] maintplan = get_object_or_404(MaintenancePlan, name=self.maintplan_name) self.release_name = self.kwargs['release_name'] release = get_object_or_404(Release, plan=maintplan, name=self.release_name) self.milestone_name = self.kwargs['milestone_name'] milestone = get_object_or_404(Milestone, release=release, name=self.milestone_name) self.milestone_statistics = _get_milestone_statistics(milestone) context['recipes_percentage'] = self.milestone_statistics['percentage'] context['recipes_all_upgraded'] = self.milestone_statistics[ 'all_upgraded'] context['recipes_all_not_upgraded'] = self.milestone_statistics[ 'all_not_upgraded'] context['recipes_up_to_date'] = self.milestone_statistics['up_to_date'] context['recipes_not_updated'] = self.milestone_statistics[ 'not_updated'] context['recipes_cant_be_updated'] = self.milestone_statistics[ 'cant_be_updated'] context['recipes_unknown'] = self.milestone_statistics['unknown'] context['recipes_percentage_up_to_date'] = \ self.milestone_statistics['percentage_up_to_date'] context['recipes_percentage_not_updated'] = \ self.milestone_statistics['percentage_not_updated'] context['recipes_percentage_cant_be_updated'] = \ self.milestone_statistics['percentage_cant_be_updated'] context['recipes_percentage_unknown'] = \ self.milestone_statistics['percentage_unknown'] # *** Upstream status chart *** statuses = [] status_counts = {} statuses.append('Up-to-date') status_counts['Up-to-date'] = self.milestone_statistics['up_to_date'] statuses.append('Not updated') status_counts['Not updated'] = self.milestone_statistics['not_updated'] statuses.append('Can\'t be updated') status_counts['Can\'t be updated'] = self.milestone_statistics[ 'cant_be_updated'] statuses.append('Unknown') status_counts['Unknown'] = self.milestone_statistics['unknown'] statuses = sorted(statuses, key=lambda status: status_counts[status], reverse=True) context['chart_upstream_status_labels'] = statuses context['chart_upstream_status_values'] = [ status_counts[k] for k in statuses ] # *** Patch status chart *** patch_statuses = [] patch_status_counts = {} for maintplanlayer in maintplan.maintenanceplanlayerbranch_set.all(): layerbranch = maintplanlayer.layerbranch patches = Patch.objects.filter(recipe__layerbranch=layerbranch) for choice, desc in Patch.PATCH_STATUS_CHOICES: if desc not in patch_statuses: patch_statuses.append(desc) patch_status_counts[desc] = patch_status_counts.get( desc, 0) + patches.filter(status=choice).count() patch_statuses = sorted(patch_statuses, key=lambda status: patch_status_counts[status], reverse=True) context['chart_patch_status_labels'] = patch_statuses context['chart_patch_status_values'] = [ patch_status_counts[k] for k in patch_statuses ] return context
def render_to_response(self, context, **response_kwargs): response_kwargs['current_app'] = resolve(self.request.path).namespace return super(BaseBlogView, self).render_to_response(context, **response_kwargs)
def test_root_url_resolves_to_home_page_view(self): found = resolve('/') #2 self.assertEqual(found.func, home_page) #check root is the homepage
def test_resolve_forms(self): resolved = resolve('/forms' + self.url_noid) self.assertEqual(resolved.view_name, 'creation-forms') resolved = resolve('/forms' + self.url_withid) self.assertEqual(resolved.view_name, 'update-forms')
def test_url_resolves_to_blogs_edit_by_slug_view(self): found = resolve("/blogs/slug-slug/edit/") self.assertEqual(found.func, blog_edit_by_slug)
def get_context_data(self, **kwargs): context = super(RecipeListView, self).get_context_data(**kwargs) context['this_url_name'] = resolve(self.request.path_info).url_name context['all_maintplans'] = MaintenancePlan.objects.all() context['maintplan_name'] = self.maintplan_name maintplan = get_object_or_404(MaintenancePlan, name=self.maintplan_name) context['maintplan'] = maintplan context['release_name'] = self.release_name context['all_releases'] = Release.objects.filter( plan=maintplan).order_by('-end_date') context['milestone_name'] = self.milestone_name context['all_milestones'] = Milestone.get_by_release_name( maintplan, self.release_name) current = date.today() current_release = Release.get_by_date(maintplan, current) if current_release: current_milestone = Milestone.get_by_release_and_date( current_release, current) if not current_milestone: messages.error( self.request, 'There is no milestone defined in the latest release (%s) that covers the current date, so data shown here is not up-to-date. The administrator will need to create a milestone in order to fix this.' % current_release) else: messages.error( self.request, 'There is no release defined that covers the current date, so data shown here is not up-to-date. The administrator will need to create a release (and corresponding milestones) in order to fix this.' ) context['recipes_percentage'] = self.milestone_statistics['percentage'] context['recipes_all_upgraded'] = self.milestone_statistics[ 'all_upgraded'] context['recipes_all_not_upgraded'] = self.milestone_statistics[ 'all_not_upgraded'] context['recipes_up_to_date'] = self.milestone_statistics['up_to_date'] context['recipes_not_updated'] = self.milestone_statistics[ 'not_updated'] context['recipes_cant_be_updated'] = self.milestone_statistics[ 'cant_be_updated'] context['recipes_unknown'] = self.milestone_statistics['unknown'] context['recipes_percentage_up_to_date'] = \ self.milestone_statistics['percentage_up_to_date'] context['recipes_percentage_not_updated'] = \ self.milestone_statistics['percentage_not_updated'] context['recipes_percentage_cant_be_updated'] = \ self.milestone_statistics['percentage_cant_be_updated'] context['recipes_percentage_unknown'] = \ self.milestone_statistics['percentage_unknown'] context['recipe_list_count'] = self.recipe_list_count context['upstream_status'] = self.upstream_status ruch = RecipeUpstream.RECIPE_UPSTREAM_STATUS_CHOICES_DICT context['upstream_status_set_choices'] = [ruch['A']] context['upstream_status_choices'] = [ ruch['N'], ruch['C'], ruch['Y'], ruch['U'] ] context['maintainer_name'] = self.maintainer_name context['set_maintainers'] = ['All', 'No maintainer'] all_maintainers = [] for layerbranch_id, rmh in self.recipe_maintainer_history.items(): for rm in RecipeMaintainer.objects.filter( history=rmh).values('maintainer__name').distinct( ).order_by('maintainer__name'): if rm['maintainer__name'] in context['set_maintainers']: continue all_maintainers.append(rm['maintainer__name']) context['all_maintainers'] = all_maintainers context['search'] = self.search return context
def test_url_resolves_to_blogs_create_view(self): found = resolve("/blogs/create/") self.assertEqual(found.func, blog_create)
def test_url_resolves_to_blogs_page_view(self): found = resolve("/blogs/") self.assertEqual(found.func, blogs_home)
def test_url_resolves_to_blogs_delete_by_id_view(self): found = resolve("/blogs/123/delete/") self.assertEqual(found.func, blog_delete_by_id)
def test_url_resolves_to_blogs_edit_by_id_view(self): found = resolve("/blogs/123/edit/") self.assertEqual(found.func, blog_edit_by_id)
def test_viewproducts_resolves(self): page = resolve('/products/') self.assertEqual(page.func, viewproducts)
def test_url_resolves_to_blogs_delete_by_slug_view(self): found = resolve("/blogs/slug-slug/delete/") self.assertEqual(found.func, blog_delete_by_slug)
def test_checkin_url_resolves(self): found = resolve('/checkin/') self.assertEqual(found.func, checkin.home)
def test_url_resolves_to_blogs_details_by_slug_view(self): found = resolve('/blogs/slug-slug/') self.assertEqual(found.func, blog_details_by_slug)
def details(request, slug): """ The main view of the Django-CMS! Takes a request and a slug, renders the page. """ if get_cms_setting("PAGE_CACHE") and ( not hasattr(request, 'toolbar') or ( not request.toolbar.edit_mode and not request.toolbar.show_toolbar and not request.user.is_authenticated() ) ): cache_content = get_page_cache(request) if cache_content is not None: content, headers = cache_content response = HttpResponse(content) response._headers = headers return response # Get a Page model object from the request page = get_page_from_request(request, use_path=slug) if not page: return _handle_no_page(request, slug) current_language = request.GET.get('language', None) if not current_language: current_language = request.POST.get('language', None) if current_language: current_language = get_language_code(current_language) if current_language not in get_language_list(page.site_id): current_language = None if current_language is None: current_language = get_language_code(getattr(request, 'LANGUAGE_CODE', None)) if current_language: current_language = get_language_code(current_language) if current_language not in get_language_list(page.site_id): current_language = None if current_language is None: current_language = get_language_code(get_language()) # Check that the current page is available in the desired (current) language available_languages = [] # this will return all languages in draft mode, and published only in live mode page_languages = list(page.get_published_languages()) if hasattr(request, 'user') and request.user.is_staff: user_languages = get_language_list() else: user_languages = get_public_languages() for frontend_lang in user_languages: if frontend_lang in page_languages: available_languages.append(frontend_lang) # Check that the language is in FRONTEND_LANGUAGES: own_urls = [ 'http%s://%s%s' % ('s' if request.is_secure() else '', request.get_host(), request.path), '/%s' % request.path, request.path, ] if not current_language in user_languages: #are we on root? if not slug: #redirect to supported language languages = [] for language in available_languages: languages.append((language, language)) if languages: # get supported language new_language = get_language_from_request(request) if new_language in get_public_languages(): with force_language(new_language): pages_root = reverse('pages-root') if hasattr(request, 'toolbar') and request.user.is_staff and request.toolbar.edit_mode: request.toolbar.redirect_url = pages_root elif pages_root not in own_urls: return HttpResponseRedirect(pages_root) elif not hasattr(request, 'toolbar') or not request.toolbar.redirect_url: _handle_no_page(request, slug) else: return _handle_no_page(request, slug) if current_language not in available_languages: # If we didn't find the required page in the requested (current) # language, let's try to find a fallback found = False for alt_lang in get_fallback_languages(current_language): if alt_lang in available_languages: if get_redirect_on_fallback(current_language) or slug == "": with force_language(alt_lang): path = page.get_absolute_url(language=alt_lang, fallback=True) # In the case where the page is not available in the # preferred language, *redirect* to the fallback page. This # is a design decision (instead of rendering in place)). if hasattr(request, 'toolbar') and request.user.is_staff and request.toolbar.edit_mode: request.toolbar.redirect_url = path elif path not in own_urls: return HttpResponseRedirect(path) else: found = True if not found and (not hasattr(request, 'toolbar') or not request.toolbar.redirect_url): # There is a page object we can't find a proper language to render it _handle_no_page(request, slug) if apphook_pool.get_apphooks(): # There are apphooks in the pool. Let's see if there is one for the # current page # since we always have a page at this point, applications_page_check is # pointless # page = applications_page_check(request, page, slug) # Check for apphooks! This time for real! app_urls = page.get_application_urls(current_language, False) skip_app = False if not page.is_published(current_language) and hasattr(request, 'toolbar') and request.toolbar.edit_mode: skip_app = True if app_urls and not skip_app: app = apphook_pool.get_apphook(app_urls) pattern_list = [] for urlpatterns in get_app_urls(app.urls): pattern_list += urlpatterns try: view, args, kwargs = resolve('/', tuple(pattern_list)) return view(request, *args, **kwargs) except Resolver404: pass # Check if the page has a redirect url defined for this language. redirect_url = page.get_redirect(language=current_language) if redirect_url: if (is_language_prefix_patterns_used() and redirect_url[0] == "/" and not redirect_url.startswith( '/%s/' % current_language)): # add language prefix to url redirect_url = "/%s/%s" % (current_language, redirect_url.lstrip("/")) # prevent redirect to self if hasattr(request, 'toolbar') and request.user.is_staff and request.toolbar.edit_mode: request.toolbar.redirect_url = redirect_url elif redirect_url not in own_urls: return HttpResponseRedirect(redirect_url) # permission checks if page.login_required and not request.user.is_authenticated(): return redirect_to_login(urlquote(request.get_full_path()), settings.LOGIN_URL) if hasattr(request, 'toolbar'): request.toolbar.set_object(page) template_name = get_template_from_request(request, page, no_current_page=True) # fill the context context = RequestContext(request) context['lang'] = current_language context['current_page'] = page context['has_change_permissions'] = page.has_change_permission(request) context['has_view_permissions'] = page.has_view_permission(request) if not context['has_view_permissions']: return _handle_no_page(request, slug) response = TemplateResponse(request, template_name, context) response.add_post_render_callback(set_page_cache) # Add headers for X Frame Options - this really should be changed upon moving to class based views xframe_options = page.get_xframe_options() # xframe_options can be None if there's no xframe information on the page # (eg. a top-level page which has xframe options set to "inherit") if xframe_options == Page.X_FRAME_OPTIONS_INHERIT or xframe_options is None: # This is when we defer to django's own clickjacking handling return response # We want to prevent django setting this in their middlewear response.xframe_options_exempt = True if xframe_options == Page.X_FRAME_OPTIONS_ALLOW: # Do nothing, allowed is no header. return response elif xframe_options == Page.X_FRAME_OPTIONS_SAMEORIGIN: response['X-Frame-Options'] = 'SAMEORIGIN' elif xframe_options == Page.X_FRAME_OPTIONS_DENY: response['X-Frame-Options'] = 'DENY' return response
def test_root_url_resolves_to_home_page_view(self): # Django uses resolve() to resolve URLs and find what view function they should map to. found = resolve('/') # Checking tht resolve(), when called with the root of the site, finds a function called home_page self.assertEqual(found.func, home_page)
def test_url_root_resolve_uses_index_view(self): found = resolve("/") self.assertEqual(found.func.__name__, IndexView.__name__)
def get_channel_address(request): dt = request.GET cart_id = cart._cart_id(request) if request.user.is_authenticated(): try: cur_session = LugatiShoppingSession.objects.get(cart_id=cart_id) except: cur_session = LugatiShoppingSession() cur_session.cart_id = cart_id cur_session.is_admin = True cur_session.company = LugatiUserProfile.objects.get( user=request.user).get_company() cur_session.save() return HttpResponse( json.dumps({ 'channel_url': 'ws://' + str(settings.NOTIFICATION_SERVER) + ':' + str(settings.NOTIFICATION_SERVER_PORT) + '/mps_notifications_channel/' + str(dt['channel_type']) + '/' + str(cur_session.id) + '/', 'session_id': cur_session.id })) else: if 'is_admin' in dt: dev_id = dt['dev_id'] try: cur_session = LugatiShoppingSession.objects.get(cart_id=dev_id) except: cur_session = LugatiShoppingSession() cur_session.cart_id = dev_id cur_session.is_admin = True cur_session.save() return HttpResponse( json.dumps({ 'channel_url': 'ws://' + str(settings.NOTIFICATION_SERVER) + ':' + str(settings.NOTIFICATION_SERVER_PORT) + '/mps_notifications_channel/' + str(dt['channel_type']) + '/' + str(cur_session.id) + '/', 'session_id': cur_session.id })) else: if 'cur_path' in dt: resolved_path = resolve(dt['cur_path']) pos_id = resolved_path.kwargs['pos_id'] place = ShoppingPlace.objects.get(pk=pos_id) cur_company = place.shop.company logger.info('getting cart_id: ' + str(cart_id)) try: cur_session = LugatiShoppingSession.objects.filter( cart_id=cart_id)[0] except: cur_session = LugatiShoppingSession() cur_session.cart_id = cart_id cur_session.company = cur_company cur_session.save() return HttpResponse( json.dumps({ 'channel_url': 'ws://' + str(settings.NOTIFICATION_SERVER) + ':' + str(settings.NOTIFICATION_SERVER_PORT) + '/mps_notifications_channel/' + str(dt['channel_type']) + '/' + str(cur_session.id) + '/', 'session_id': cur_session.id }))
def test_org_collection_version_edit_url_to_viewname(self): resolver = resolve('/orgs/org/collections/coll/v1/json/edit/') self.assertEqual(resolver.view_name, 'collection-version-json-edit') self.assertEqual(resolver.kwargs['org'], 'org') self.assertEqual(resolver.kwargs['collection'], 'coll') self.assertEqual(resolver.kwargs['collection_version'], 'v1')
def test_root_url_resolves_to_home_page_view(self): """ Test to ensure that root url goes to somewhere/ """ found = resolve('/') self.assertEqual(found.func, home_page)
def test_url_to_collections_versions_viewname(self): resolver = resolve('/orgs/myorgs/collections/collection1/versions/') self.assertEqual(resolver.view_name, 'collection-versions')
def process_request(self, request): if get_flavour(request) == 'amp': from django.core.urlresolvers import resolve current_url = resolve(request.path_info).url_name if current_url != 'article_detail': set_flavour('mobile', request, permanent=True)