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)
