def _get_url_resolver():
try:
return urlresolvers.get_resolver(
import_module(urlresolvers.get_urlconf(settings.ROOT_URLCONF)))
except AttributeError:
# A weird error we can't reproduce but which is solved with this patch. See #2229
return urlresolvers.get_resolver(import_module(settings.ROOT_URLCONF))
def kolibri_set_urls(context):
# Modified from:
# https://github.com/ierror/django-js-reverse/blob/master/django_js_reverse/core.py#L101
js_global_object_name = "window"
js_var_name = "kolibriUrls"
script_prefix = get_script_prefix()
if "request" in context:
default_urlresolver = get_resolver(
getattr(context["request"], "urlconf", None))
else:
default_urlresolver = get_resolver(None)
js = render_to_string(
"django_js_reverse/urls_js.tpl",
{
"urls": sorted(list(prepare_url_list(default_urlresolver))),
"url_prefix": script_prefix,
"js_var_name": js_var_name,
"js_global_object_name": js_global_object_name,
},
)
return mark_safe("""<script type="text/javascript">""" + jsmin(js) + """
{global_object}.staticUrl = '{static_url}';
{global_object}.mediaUrl = '{media_url}';
</script>
""".format(
global_object=js_global_object_name,
static_url=settings.STATIC_URL,
media_url=settings.MEDIA_URL,
))
def get_admin_methods():
admin_methods = []
for key in get_resolver(None).reverse_dict.keys():
url = str(get_resolver(None).reverse_dict[key][1])
if url.startswith('admin/'):
admin_methods.append({'name': key.__name__, 'url': '/' + url})
return admin_methods
def shop_instance():
# Load default URL patterns to ensure that the shop
# object has been created
from django.core.urlresolvers import get_resolver
get_resolver(None)._populate()
return _shop_instance
def testMultiModuleMixedURL(self):
self.assertEqual(
get_resolver(None).resolve('/en/garfield/jim-davis/')[0],
jim_davis)
translation.activate('fr')
self.assertEqual(
get_resolver(None).resolve('/fr/garfield/jim-davis/')[0],
jim_davis)
def testMultiModuleTransURL(self):
self.assertEqual(
get_resolver(None).resolve(u'/en/garfield/the-president/')[0],
the_president)
translation.activate('fr')
self.assertEqual(
get_resolver(None).resolve(u'/fr/garfield/le-président/')[0],
the_president)
def js_reverse_inline(context):
"""
Outputs a string of javascript that can generate URLs via the use
of the names given to those URLs.
"""
if 'request' in context:
default_urlresolver = urlresolvers.get_resolver(getattr(context['request'], 'urlconf', None))
else:
default_urlresolver = urlresolvers.get_resolver(None)
return mark_safe(generate_js(default_urlresolver))
def reverse(viewname,
urlconf=None,
args=None,
kwargs=None,
prefix=None,
current_app=None):
u"""
Django ``reverse()`` expects exactly the same arguments as parsed from url. However, sometimes
it is more convenient to call ``reverse()`` with complex objects that can be reduced to url
arguments automatically. Suppose we have model "Author" that is represented by its "pk" and
"name" in the url:
url(r'^/(?P<name>\w+)/(?P<pk>\d+)/$', author_view, name='detail')
Instead of writing:
reverse('detail', kwargs=dict(name=author.name, pk=author.pk))
{% url 'detail' name=author.name pk=author.pk %}
We may write simply:
reverse('detail', kwargs=dict(author=author))
{% url 'detail' author=author %}
If we register the following reverse adaptor:
@reverse_adaptor('detail', 'author')
def author_adaptor(author):
return dict(name=author.name, pk=author.pk)
Further, this function strips ``kwargs`` of all None values and ``args`` of all trailing None
values as Django ``reverse()`` breaks if given None as an argument. Django resolver may
populate arguments with None when parsing certain urls, therefore it's not possible to
recostruct such urls with Django ``reverse()``. Unfortunatelly, if None occurs in the middle of
``args`` there is no way to fix it.
"""
# Make sure urls were included. Otherwise the adaptors don't have to be registered yet if this
# is the first call to the resolver.
get_resolver(urlconf or get_urlconf())._populate()
for argname, adaptor in reverse_adaptors[viewname]:
if kwargs and argname in kwargs:
kwargs.update(adaptor(kwargs.pop(argname)))
if args is not None:
while args and args[-1] is None:
args = args[:-1]
if kwargs is not None:
kwargs = dict((k, v) for k, v in kwargs.iteritems() if v is not None)
return django_reverse(viewname, urlconf, args, kwargs, prefix, current_app)
def shop_instance():
"""
This method ensures that all views and URLs are properly loaded, and
returns the centrally instantiated :class:`plata.shop.views.Shop` object.
"""
if not shop_instance_cache:
# Load default URL patterns to ensure that the shop
# object has been created
from django.core.urlresolvers import get_resolver
get_resolver(None)._populate()
return shop_instance_cache
def shop_instance():
"""
This method ensures that all views and URLs are properly loaded, and
returns the centrally instantiated :class:`plata.shop.views.Shop` object.
"""
if not shop_instance_cache:
# Load default URL patterns to ensure that the shop
# object has been created
from django.core.urlresolvers import get_resolver
get_resolver(None)._populate()
return shop_instance_cache
def get_resource_uri_template(self):
"""
URI template processor.
See http://bitworking.org/projects/URI-Templates/
"""
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
lookup_view = get_callable(lookup_view, True)
possibilities = get_resolver(
'anaf.core.api.urls').reverse_dict.getlist(lookup_view)
for possibility, pattern in possibilities:
for result, params in possibility:
if args:
if len(args) != len(params):
continue
return _convert(result, params)
else:
if set(kwargs.keys()) != set(params):
continue
return _convert(result, params)
except:
return None
def pingback_extensions_get_pingbacks(target):
"""pingback.extensions.getPingbacks(url) => '[url, url, ...]'
Returns an array of URLs that link to the specified url.
See: http://www.aquarionics.com/misc/archives/blogite/0198.html"""
site = Site.objects.get_current()
scheme, netloc, path, query, fragment = urlsplit(target)
if netloc != site.domain:
return TARGET_DOES_NOT_EXIST
resolver = get_resolver(None)
try:
resolver.resolve(path)
except Resolver404:
return TARGET_DOES_NOT_EXIST
try:
entry_slug = [bit for bit in path.split('/') if bit][-1]
entry = Entry.published.get(slug=entry_slug)
except (Entry.DoesNotExist, IndexError):
return TARGET_IS_NOT_PINGABLE
return [pingback.user_url for pingback in entry.pingbacks]
def dispatch_reverse(namespace, dispatchable, method='read',
dconf='dispatch_urls', format=None, suffix=None):
''' Looks up a middleware handler CRUD method
namespace => the namespace of the handler
dispatchable => the type of dispatchable that will be sent
method => the CRUD method name
dconf => a module name containing the name/url mappings formatted as
per the standard django urls.py
format => use if multiple formats are supported; i.e json, xml
suffix => an additional flag; implementation dependent
'''
if method not in CRUD.values():
raise Exception
urlconf = '.'.join((namespace,dconf))
parts = [dispatchable,method,]
name = '-'.join(parts)
if format:
name+= '-' + format
if suffix:
name+= '-' + suffix
resolver = urlresolvers.get_resolver(urlconf)
try:
return resolver.reverse(name)
except Exception as e:
tb = sys.exc_info()[2]
for item in traceback.format_tb(tb):
print 'dispatch_reverse:::' , item
return ''
def __init__(self):
self._supported_languages = OrderedDict(settings.LANGUAGES)
self._is_language_prefix_patterns_used = False
for url_pattern in get_resolver(None).url_patterns:
if isinstance(url_pattern, LocaleRegexURLResolver):
self._is_language_prefix_patterns_used = True
break
def return_urls(handler):
def _convert(template, params=[]):
"""URI template converter"""
paths = template % dict([p, "{%s}" % p] for p in params)
return u'%s%s' % (get_script_prefix(), paths)
try:
resource_uri = handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
lookup_view = get_callable(lookup_view, True)
urls = []
possibilities = get_resolver(None).reverse_dict.getlist(lookup_view)
for possibility, pattern, empty in possibilities:
for result, params in possibility:
urls.append(_convert(result, params))
return urls
except:
return None
def test_views_work(self):
"""
Views return a 200 status code with the expected content
"""
ok_count = 0
total_count = 0
urls = get_resolver(None).reverse_dict.keys()
print("\n\nTesting views")
for url in urls:
if isinstance(url, str):
try:
response = self.client.get(reverse(url))
self.assertEqual(response.status_code, 200)
print("Tested ok: " + url)
ok_count += 1
total_count += 1
except Exception as ex:
if not isinstance(ex, NoReverseMatch):
print("\n!!! Could not load " + url + " due to " +
str(ex) + "\n")
total_count += 1
else:
print("(Needs own test view with URL parameters: " +
url + ")")
print(str(ok_count) + "/" + str(total_count) + " views ok")
def get_paths_doc(self):
paths_doc = dict()
resolver = get_resolver()
for item in resolver.reverse_dict.items():
url_path, path_doc = self.get_path_doc(*item)
paths_doc[url_path] = path_doc
return paths_doc
def generic_view(target_url):
"""
Tries to figure out, of the view is a generic view and determines which
object is served by the view.
"""
try:
urlresolver = get_resolver(None)
site = Site.objects.get_current()
func, args, kwargs = urlresolver.resolve(target_url.replace("https://%s"%site.domain, ''))
if func.__name__ == 'object_detail':
# may be django's generic view or something which at least works in an similar fashion
if 'object_id' in kwargs:
if 'queryset' in kwargs:
try:
obj = kwargs['queryset'].get(pk=kwargs['object_id'])
return obj
except Exception, e:
pass
elif 'model' in kwargs:
try:
obj = kwargs['model'].objects.get(pk=kwargs['object_id'])
return obj
except Exception, e:
pass
elif 'slug' in kwargs and 'slug_field' in kwargs:
try:
obj = kwargs['queryset'].get(**{kwargs['slug_field']: kwargs['slug'],})
return obj
except Exception, e:
pass
def get_resource_uri_template(self):
"""
URI template processor.
See http://bitworking.org/projects/URI-Templates/
"""
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
lookup_view = get_callable(lookup_view, True)
possibilities = get_resolver('maker.core.api.urls').reverse_dict.getlist(lookup_view)
for possibility, pattern in possibilities:
for result, params in possibility:
if args:
if len(args) != len(params):
continue
return _convert(result, params)
else:
if set(kwargs.keys()) != set(params):
continue
return _convert(result, params)
except:
return None
def get_resource_uri_index(self):
"""
INDEX URI template processor.
"""
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
# else this url will be in get_resource_uri_template
if args or kwargs:
lookup_view = get_callable(lookup_view, True)
possibilities = get_resolver('maker.core.api.urls').reverse_dict.getlist(lookup_view)
for possibility, pattern in possibilities:
for result, params in possibility:
if not params:
return _convert(result)
except:
return None
def process_request(self, request):
# Allow access if middleware is not activated
if not settings.MAINTENANCE_MODE:
return None
# Preferentially check HTTP_X_FORWARDED_FOR b/c a proxy
# server might have obscured REMOTE_ADDR
for ip in request.META.get('HTTP_X_FORWARDED_FOR', '').split(','):
if ip.strip() in settings.INTERNAL_IPS:
return None
# Allow access if remote ip is in INTERNAL_IPS
if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
return None
# Allow access if the user doing the request is logged in and a
# staff member.
if hasattr(request, 'user') and request.user.is_staff:
return None
# Check if a path is explicitly excluded from maintenance mode
for url in IGNORE_URLS:
if url.match(request.path_info):
return None
# Otherwise show the user the 503 page
resolver = urlresolvers.get_resolver(None)
if django.VERSION < (1, 8):
callback, param_dict = resolver._resolve_special('503')
else:
callback, param_dict = resolver.resolve_error_handler('503')
return callback(request, **param_dict)
def get_form(self, request, obj=None, **kwargs):
"""Returns modified form for TreeItem model.
'Parent' field choices are built by sitetree itself.
"""
if obj is not None and obj.parent is not None:
self.previous_parent = obj.parent
previous_parent_id = self.previous_parent.id
else:
previous_parent_id = None
my_choice_field = TreeItemChoiceField(self.tree, initial=previous_parent_id)
form = super(TreeItemAdmin, self).get_form(request, obj, **kwargs)
my_choice_field.label = form.base_fields['parent'].label
my_choice_field.help_text = form.base_fields['parent'].help_text
# Replace 'parent' TreeItem field with new appropriate one
form.base_fields['parent'] = my_choice_field
# Try to resolve all currently registered url names including those in namespaces.
if not getattr(self, 'known_url_names', False):
self.known_url_names = []
self.known_url_rules = []
resolver = get_resolver(get_urlconf())
for ns, (url_prefix, ns_resolver) in resolver.namespace_dict.items():
if ns != 'admin':
self._stack_known_urls(ns_resolver.reverse_dict, ns)
self._stack_known_urls(resolver.reverse_dict)
self.known_url_rules = sorted(self.known_url_rules)
form.known_url_names_hint = _(
'You are seeing this warning because "URL as Pattern" option is active and pattern entered above '
'seems to be invalid. Currently registered URL pattern names and parameters: ')
form.known_url_names = self.known_url_names
form.known_url_rules = self.known_url_rules
return form
def get_paths_doc(self):
paths_doc = {}
resolver = get_resolver()
for view_func, url_pattern in resolver.reverse_dict.items():
url_path, path_parameters = url_pattern[0][0]
url_path = self.unify_url_path(url_path)
view_class = view_func.view_class
path_doc = OrderedDict()
paths_doc[url_path] = path_doc
path_parameter_doc = self.get_path_parameter_doc(view_class)
if path_parameter_doc:
path_doc['parameters'] = path_parameter_doc
doc_parameters = set(parameter['name']
for parameter in path_parameter_doc
if parameter['in'] == 'path')
real_parameters = set(re.findall(r'\{([^{}/]+)\}', url_path))
if not doc_parameters == real_parameters:
msg = 'doc_parameters {} and real_parameters {} does '\
'not match '.format(doc_parameters, real_parameters)
raise ValueError(msg)
# check path parameter match doc or not
for method in view_class.http_method_names:
if not hasattr(view_class, method):
continue
method_func = getattr(view_class, method)
path_method_doc = self.get_path_method_doc(method_func)
if not path_method_doc:
if method == 'options':
continue
path_method_doc = self.default_path_method_doc
path_doc[method] = path_method_doc
return paths_doc
def get_resource_uri_template(self):
"""
URI template processor.
See http://bitworking.org/projects/URI-Templates/
"""
def _convert(template, params=[]):
"""URI template converter"""
paths = template % dict([p, "{%s}" % p] for p in params)
return u'%s%s' % (get_script_prefix(), paths)
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
lookup_view = get_callable(lookup_view, True)
possibilities = get_resolver(None).reverse_dict.getlist(lookup_view)
for possibility, pattern in possibilities:
for result, params in possibility:
if args:
if len(args) != len(params):
continue
return _convert(result, params)
else:
if set(kwargs.keys()) != set(params):
continue
return _convert(result, params)
except:
return None
def wrap(klass):
model = getattr(klass, 'model', None)
# Retrieves and sets the dispatchable type if not explictly declared
# from model
if model:
obj = getattr(model._meta, 'module_name', None)
setattr(klass, 'dispatchable', obj)
else:
obj = getattr(klass, 'dispatchable', None)
# rest of the method meaningless if no dispatchable
if not obj:
return klass
# check for dispatcher namespace registered for the dispatchable
module = _mDConf.get_dispatcher(obj) if obj else None
if not module:
return klass
# use the django urlconf mechanism to get the handler whose methods
# we will remap to
uconf = '{0}.{1}'.format(module, 'urls')
match = urlresolvers.reverse(obj, urlconf=uconf)
resource, _, _ = urlresolvers.get_resolver(uconf).resolve(match)
handler = resource.handler
# remap the methods
allowed_methods = getattr(klass, 'dispatch_methods', [])
for method in allowed_methods:
f = CRUD[method]
new_f = '_dispatch_' + f
crud = getattr(handler, f)
setattr(klass, new_f, crud)
def test_resolution(self):
r = get_resolver(None)
geoids = '10,10001,10002,10003,10001040100'
extensions = ["html", "csv", "json"]
geoids = geoids.split(',')
test = []
while geoids:
test.append(geoids.pop())
geoid_str = ",".join(test)
for extension in extensions:
path = "/data/%s.%s" % (geoid_str, extension)
self.log.debug("asking for %s" % path)
match = r.resolve(path)
self.assertEquals(1,len(match.kwargs))
self.assertEquals(geoid_str,match.kwargs['geoids'])
# A couple paths that should fail.
self.assertRaises(
Resolver404,
r.resolve,
"/data/10.foo"
)
self.assertRaises(
Resolver404,
r.resolve,
"/data/bunk.html"
)
def mDispatch_reverse(namespace,
dispatchable,
method='read',
dconf='dispatch_urls',
format=None,
suffix=None):
if method not in CRUD.values():
raise Exception
urlconf = '.'.join((namespace, dconf))
parts = [
dispatchable,
method,
]
name = '-'.join(parts)
if format:
name += '-' + format
if suffix:
name += '-' + suffix
resolver = urlresolvers.get_resolver(urlconf)
try:
return resolver.reverse(name)
except:
tb = sys.exc_info()[2]
for item in traceback.format_tb(tb):
print 'dispatch_reverse:::', item
return u''
def _generate_model_type_link(self, obj, kwargs):
"""Helper function to generate a url for a result item of a model option.
Keyword arguments:
obj -- The result model object.
kwargs -- The url keyword arguments from the current request's url.
"""
try:
url_kwargs = {}
resolver = get_resolver(None)
# Loop through the arguments required for reversing this url and extract
# only the required ones from the request's keyword args.
for arg_name in resolver.reverse_dict[self.url_name][0][0][1]:
if arg_name == self.url_id:
# If the argument is the extra one added by the model menu type then
# put it in specially.
url_kwargs[arg_name] = str(getattr(obj, self.model_id))
elif arg_name not in kwargs:
# If there's a missing argument then return None - there won't be
# any link being generated here...
return None
else:
# Otherwise just add it to the dictionary.
url_kwargs[arg_name] = kwargs[arg_name]
# Generate the url.
url = reverse(self.url_name, kwargs=url_kwargs)
return url
except NoReverseMatch, e:
return None
def process_response(self, request, response):
"""
If request status code is other than 404, just return provided response.
If request status code is 404:
- if request.path can be resolved in context of a language from
`settings.Languages`, call `handle_successful_match` and return it's
result
- if request.path cannot be resolved in context of a language from
`settings.Languages` return provided response.
"""
if response.status_code == 404:
all_languages = [i[0] for i in settings.LANGUAGES]
resolver = get_resolver(None)
for language in all_languages:
match = try_url_for_language(request.path, language, resolver)
if match is not None:
return self.handle_successful_match(
request,
response,
match[0],
match[1],
match[2],
language
)
return response
else:
return response
def test_error_handlers(rf):
"""
Test that SHOOP_FRONT_INSTALL_ERROR_HANDLERS installs error handlers
without overwriting possible custom ones.
"""
with override_settings(
DEBUG=False,
SHOOP_FRONT_INSTALL_ERROR_HANDLERS=True,
MIDDLEWARE_CLASSES=[]
):
with replace_urls([
url("^aaargh/", errorful_view)
], {"handler404": four_oh_four}):
resolver = get_resolver(None)
urlconf = resolver.urlconf_module
install_error_handlers()
assert callable(urlconf.handler500) # We get a new 500 handler
assert urlconf.handler404 == four_oh_four # Our custom 404 handler didn't get overwritten
handler = BaseHandler()
handler.load_middleware()
# Test 500
response = handler.get_response(rf.get("/aaargh/"))
assert response.status_code == 500 # Uh oh!
assert isinstance(response, TemplateResponse) # Looks good!
assert response.template_name.startswith("shoop") # Woop!
# Test 404
response = handler.get_response(rf.get("/another_castle/"))
assert response.status_code == 200 # Our custom 404 handler made it a 200!
assert b"flesh wound" in response.content
def get_resource_uri_template(self):
"""
URI template processor.
See http://bitworking.org/projects/URI-Templates/
"""
def _convert(template, params=[]):
"""URI template converter"""
paths = template % dict([p, "{%s}" % p] for p in params)
return u'%s%s' % (get_script_prefix(), paths)
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
lookup_view = get_callable(lookup_view, True)
possibilities = get_resolver(None).reverse_dict.getlist(lookup_view)
# The monkey patch is right here: we need to cope with 'possibilities'
# being a list of tuples with 2 or 3 elements.
for possibility_data in possibilities:
possibility = possibility_data[0]
for result, params in possibility:
if args:
if len(args) != len(params):
continue
return _convert(result, params)
else:
if set(kwargs.keys()) != set(params):
continue
return _convert(result, params)
except:
return None
def _get_named_patterns():
"Returns list of (pattern-name, pattern) tuples"
resolver = urlresolvers.get_resolver(None)
patterns = sorted(
[(key, value[0][0][0]) for key, value in resolver.reverse_dict.items() if isinstance(key, basestring)]
)
return patterns
def __init__(self):
"""."""
self._is_language_prefix_patterns_used = False
for url_pattern in get_resolver(None).url_patterns:
if isinstance(url_pattern, LocaleRegexURLResolver):
self._is_language_prefix_patterns_used = True
break
def collect_urls(urls=None, namespace=None, prefix=None):
if urls is None:
urls = urlresolvers.get_resolver(urlconf=None)
prefix = prefix or []
if isinstance(urls, RegexURLResolver):
res = []
for x in urls.url_patterns:
res += collect_urls(x,
namespace=urls.namespace or namespace,
prefix=prefix + [urls.regex.pattern])
return res
elif isinstance(urls, RegexURLPattern):
if django.VERSION < (1, 10):
callback = urls._callback
lookup_str = callback.__module__ + '.'
if hasattr(callback, '__name__'):
lookup_str += callback.__name__
else:
lookup_str += callback.__class__.__name__
else: # pragma: no cover
lookup_str = urls.lookup_str
return [
OrderedDict([('namespace', namespace), ('name', urls.name),
('pattern', prefix + [urls.regex.pattern]),
('lookup_str', lookup_str),
('default_args', dict(urls.default_args))])
]
else: # pragma: no cover
raise NotImplementedError(repr(urls))
def get_wagtailadmin_tab_urls():
resolver = urlresolvers.get_resolver(None)
return [
(key, value[2].get("title", key))
for key, value in resolver.reverse_dict.items()
if isinstance(key, basestring) and key.startswith('wagtailadmin_tab_')
]
def urls(request, prefix=''):
"""
Returns javascript for mapping service endpoint names to urls.
For this view to work properly, all urls that are to be made
available and are using regular expressions for defining
parameters must use named parameters.
The view uses Django internal url resolver to iterate over a list
of all currently defined url patterns. It looks for named patterns
and replaces each named regex group definition the group name enclosed
in curley braces. Url pattern names will be translated into
javascript variable names by converting all letters to the upper
case and replacing '-' with '_'.
"""
resolver = get_resolver(None)
urls = {}
for name in resolver.reverse_dict:
if isinstance(name, str) and name.startswith(prefix):
url_regex = resolver.reverse_dict.get(name)[1]
param_names = resolver.reverse_dict.get(name)[0][0][1]
arg_pattern = r'\(\?P\<[^\)]+\)' #matches named groups in the form of (?P<name>pattern)
i = 0
for match in re.findall(arg_pattern, url_regex):
url_regex = url_regex.replace(match, "{%s}"%param_names[i])
i += 1
urls[name] = "/" + url_regex[:-1]
return request_render_to_response(request, "pollster/urls.js", {'urls':urls}, mimetype="application/javascript")
def is_language_prefix_patterns_used():
"""
Returns `True` if the `LocaleRegexURLResolver` is used
at root level of the urlpatterns, else it returns `False`.
"""
return any(isinstance(url_pattern, LocaleRegexURLResolver)
for url_pattern in get_resolver(None).url_patterns)
def wrap(klass):
model = getattr(klass, 'model', None)
# Retrieves and sets the dispatchable type if not explictly declared
# from model
if model:
obj = getattr(model._meta, 'module_name', None)
setattr(klass,'dispatchable', obj)
else:
obj = getattr(klass, 'dispatchable', None)
# rest of the method meaningless if no dispatchable
if not obj:
return klass
# check for dispatcher namespace registered for the dispatchable
module = _mDConf.get_dispatcher(obj) if obj else None
if not module:
return klass
# use the django urlconf mechanism to get the handler whose methods
# we will remap to
uconf = '{0}.{1}'.format(module, 'urls')
match = urlresolvers.reverse(obj, urlconf=uconf)
resource, _, _ = urlresolvers.get_resolver(uconf).resolve(match)
handler = resource.handler
# remap the methods
allowed_methods = getattr(klass, 'dispatch_methods', [])
for method in allowed_methods:
f = CRUD[method]
new_f = '_dispatch_'+f
crud = getattr(handler, f)
setattr(klass, new_f, crud)
def pingback_extensions_get_pingbacks(target):
"""pingback.extensions.getPingbacks(url) => '[url, url, ...]'
Returns an array of URLs that link to the specified url.
See: http://www.aquarionics.com/misc/archives/blogite/0198.html"""
site = Site.objects.get_current()
scheme, netloc, path, query, fragment = urlsplit(target)
if netloc != site.domain:
return TARGET_DOES_NOT_EXIST
resolver = get_resolver(None)
try:
resolver.resolve(path)
except Resolver404:
return TARGET_DOES_NOT_EXIST
try:
entry_slug = [bit for bit in path.split('/') if bit][-1]
entry = Entry.published.get(slug=entry_slug)
except (Entry.DoesNotExist, IndexError):
return TARGET_IS_NOT_PINGABLE
return [pingback.user_url for pingback in entry.pingbacks]
def pingback_ping(source, target):
"""pingback.ping(sourceURI, targetURI) => 'Pingback message'
Notifies the server that a link has been added to sourceURI,
pointing to targetURI.
See: http://hixie.ch/specs/pingback/pingback-1.0"""
try:
if source == target:
return UNDEFINED_ERROR
site = Site.objects.get_current()
try:
document = ''.join(urlopen(source).readlines())
except (HTTPError, URLError):
return SOURCE_DOES_NOT_EXIST
if not target in document:
return SOURCE_DOES_NOT_LINK
scheme, netloc, path, query, fragment = urlsplit(target)
if netloc != site.domain:
return TARGET_DOES_NOT_EXIST
resolver = get_resolver(None)
try:
resolver.resolve(path)
except Resolver404:
return TARGET_DOES_NOT_EXIST
try:
entry_slug = [bit for bit in path.split('/') if bit][-1]
entry = Entry.published.get(slug=entry_slug)
if not entry.pingback_enabled:
return TARGET_IS_NOT_PINGABLE
except (Entry.DoesNotExist, IndexError):
return TARGET_IS_NOT_PINGABLE
soup = BeautifulSoup(document)
title = soup.find('title')
title = title and strip_tags(title) or _('No title')
description = generate_pingback_content(soup, target,
PINGBACK_CONTENT_LENGTH)
comment, created = Comment.objects.get_or_create(
content_type=ContentType.objects.get_for_model(Entry),
object_pk=entry.pk,
user_url=source,
site=site,
defaults={
'comment': description,
'user_name': title
})
if created:
user = entry.authors.all()[0]
comment.flags.create(user=user, flag='pingback')
return 'Pingback from %s to %s registered.' % (source, target)
return PINGBACK_ALREADY_REGISTERED
except:
return UNDEFINED_ERROR
def process_request(self, request):
# Allow access if middleware is not activated
if not MAINTENANCE_MODE:
return None
# Allow access if remote ip is in INTERNAL_IPS
if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
return None
# Allow access if the user doing the request is logged in and a
# superuser.
ALLOW_SU = getattr(settings, 'MAINTENANCE_ALLOW_SU', False)
if ALLOW_SU and hasattr(request, 'user') and request.user.is_superuser:
return None
# Check if a path is explicitly excluded from maintenance mode
for url in IGNORE_URLS:
if url.match(request.path_info):
return None
# Otherwise show the user the 503 page
resolver = urlresolvers.get_resolver(None)
callback, param_dict = resolver._resolve_special('503')
return callback(request, **param_dict)
def get_wagtailadmin_tab_urls():
resolver = urlresolvers.get_resolver(None)
return [
(key, value[2].get("title", key))
for key, value in resolver.reverse_dict.items()
if isinstance(key, basestring) and key.startswith("wagtailadmin_tab_")
]
def test_all_views():
u'''
Unittest: Check if all you views have a breadcrumbs()
attribute.
Django views are ignored.
'''
resolver=urlresolvers.get_resolver(None)
missing=[]
for function, patterns in resolver.reverse_dict.items():
if not function:
continue
sub_resolver=patterns[0]
if isinstance(function, basestring): # TODO: Alias auflösen.
continue
if function.__module__.startswith('django'):
continue
name='%s.%s' % (function.__module__, function.__name__)
if not hasattr(function, 'breadcrumbs'):
missing.append(name)
continue
bc=function.breadcrumbs
if isinstance(bc, basestring):
try:
unicode(bc)
except UnicodeError, exc:
missing.append('UnicodeError, %s: %s' % (name, exc))
def process_request(self, request):
"""
Request processing method
"""
try:
site=request.site
except:
# Get current site
site = get_site_from_request(request)
try:
sitemaintenance=site.siteinfo.maintenance
except:
sitemaintenance=False
# Check if site is not marked as under maintenance or forced maintenance is specified
if settings.SITE_UNDER_MAINTENANCE or sitemaintenance:
# Allow access if client IP is in INTERNAL_IPS or logged in user is staff member
try:
is_staff=request.user.is_staff
except:
is_staff=False
if get_client_ip(request) not in settings.INTERNAL_IPS and not is_staff:
# Check if current view is whitelisted
if not match_any(request.path_info, self._MAINTENANCE_WHITELIST):
# Return 503 handler response
resolver = urlresolvers.get_resolver(None)
callback, param_dict = resolver._resolve_special('503')
return callback(request, **param_dict)
def get_form(self, request, obj=None, **kwargs):
"""Returns modified form for TreeItem model.
'Parent' field choices are built by sitetree itself.
"""
if obj is not None and obj.parent is not None:
self.previous_parent = obj.parent
previous_parent_id = self.previous_parent.id
else:
previous_parent_id = None
my_choice_field = TreeItemChoiceField(self.tree, initial=previous_parent_id)
form = super(TreeItemAdmin, self).get_form(request, obj, **kwargs)
my_choice_field.label = form.base_fields['parent'].label
my_choice_field.help_text = form.base_fields['parent'].help_text
# Replace 'parent' TreeItem field with new appropriate one
form.base_fields['parent'] = my_choice_field
# Try to resolve all currently registered url names including those in namespaces.
if not getattr(self, 'known_url_names', False):
self.known_url_names = []
self.known_url_rules = []
resolver = get_resolver(get_urlconf())
for ns, (url_prefix, ns_resolver) in resolver.namespace_dict.items():
if ns != 'admin':
self._stack_known_urls(ns_resolver.reverse_dict, ns)
self._stack_known_urls(resolver.reverse_dict)
self.known_url_rules = sorted(self.known_url_rules)
form.known_url_names_hint = _('You are seeing this warning because "URL as Pattern" option is active and pattern entered above seems to be invalid. Currently registered URL pattern names and parameters: ')
form.known_url_names = self.known_url_names
form.known_url_rules = self.known_url_rules
return form
def process_request(self, request):
# Allow access if middleware is not activated
if not MAINTENANCE_MODE:
return None
# Allow access if remote ip is in INTERNAL_IPS
if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
pass # TODO I currently don't trust internal IPs with Webfaction's proxying although it could just be a middleware order problem
#return None
# Allow acess if the user doing the request is logged in and a
# staff member.
if hasattr(request, 'user') and request.user.is_staff:
return None
# Allow admin
if not MAINTENANCE_MODE_ADMIN and request.META['PATH_INFO'].startswith(urlresolvers.reverse('admin:index')):
return None
# Allow specific urls
allow_urls = getattr(settings, 'MAINTENANCE_MODE_ALLOW_URLS', None)
if allow_urls:
for item in allow_urls:
if request.META['PATH_INFO'].startswith(item):
return None
# Otherwise show the user the 503 page
resolver = urlresolvers.get_resolver(None)
callback, param_dict = resolver._resolve_special('503')
return callback(request, **param_dict)
def get_resource_uri_index(self):
"""
INDEX URI template processor.
"""
try:
resource_uri = self.handler.resource_uri()
components = [None, [], {}]
for i, value in enumerate(resource_uri):
components[i] = value
lookup_view, args, kwargs = components
# else this url will be in get_resource_uri_template
if args or kwargs:
lookup_view = get_callable(lookup_view, True)
possibilities = get_resolver(
'anaf.core.api.urls').reverse_dict.getlist(lookup_view)
for possibility, pattern in possibilities:
for result, params in possibility:
if not params:
return _convert(result)
except:
return None
def get_all_remote_methods(resolver=None, ns_prefix=''):
"""
Returns a dictionary to be used for calling ``djangoCall.configure()``, which itself extends the
Angular API to the client, offering him to call remote methods.
"""
if not resolver:
resolver = get_resolver(get_urlconf())
result = {}
for name in resolver.reverse_dict.keys():
if not isinstance(name, six.string_types):
continue
try:
url = reverse(ns_prefix + name)
resmgr = resolve(url)
ViewClass = import_string('{0}.{1}'.format(resmgr.func.__module__,
resmgr.func.__name__))
if isclass(ViewClass) and issubclass(ViewClass, JSONResponseMixin):
result[name] = _get_remote_methods_for(ViewClass, url)
except (NoReverseMatch, ImproperlyConfigured):
pass
for namespace, ns_pattern in resolver.namespace_dict.items():
sub_res = get_all_remote_methods(ns_pattern[1],
ns_prefix + namespace + ':')
if sub_res:
result[namespace] = sub_res
return result
def process_request(self, request):
from courant.core.maintenancemode.conf.settings import MAINTENANCE_MODE
# Allow access if middleware is not activated
if not MAINTENANCE_MODE:
return None
if request.path[0:7] == '/admin/':
#Let admin access through always
return None
# Allow access if remote ip is in INTERNAL_IPS
if request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
return None
# Allow acess if the user doing the request is logged in and a
# staff member.
if hasattr(request, 'user') and request.user.is_staff:
return None
# Otherwise show the user the 503 page
resolver = urlresolvers.get_resolver(None)
callback, param_dict = resolver._resolve_special('503')
return callback(request, **param_dict)
def _generate_named_link(self, kwargs):
"""Helper function to generate a url for a named url menu option.
Keyword arguments:
kwargs -- The url keyword arguments from the current request's url.
"""
try:
url_kwargs = {}
resolver = get_resolver(None)
# Loop through the arguments required for reversing this url and extract
# only the required ones from the request's keyword args.
for arg_name in resolver.reverse_dict[self.url_name][0][0][1]:
if arg_name not in kwargs:
# If there's a missing argument then return None - there won't be
# any link being generated here...
return None
else:
# Otherwise just add it to the dictionary.
url_kwargs[arg_name] = kwargs[arg_name]
# Generate the url.
url = reverse(self.url_name, kwargs=url_kwargs)
return url
except NoReverseMatch, e:
return None
def __init__(self):
"""."""
self._is_language_prefix_patterns_used = False
for url_pattern in get_resolver(None).url_patterns:
if isinstance(url_pattern, LocaleRegexURLResolver):
self._is_language_prefix_patterns_used = True
break
def handle(self, *args, **kwargs):
urls = urlresolvers.get_resolver()
all_urls = list()
def func_for_sorting(i):
if i.name is None:
i.name = ''
return i.name
def show_urls(urls):
for url in urls.url_patterns:
if isinstance(url, RegexURLResolver):
show_urls(url)
elif isinstance(url, RegexURLPattern):
all_urls.append(url)
show_urls(urls)
all_urls.sort(key=func_for_sorting, reverse=False)
print('-' * 100)
for url in all_urls:
print(
'| {0.regex.pattern:20} | {0.name:20} | {0.lookup_str:20} | {0.default_args} |'
.format(url))
print('-' * 100)
def get_all_callbacks(urlconf):
"""
Gets the dict translating the view names to view callables for the entire
given URLconf. Does not allow duplicate view names. Views in non-empty
namespaces are prefixed with the namespace(s).
"""
callbacks = {}
def add_callbacks(resolver, namespace):
for pattern in resolver.url_patterns:
if isinstance(pattern, urlresolvers.RegexURLResolver):
ns = namespace
if pattern.namespace:
ns += (':' if ns else '') + pattern.namespace
add_callbacks(pattern, ns)
elif pattern.name is not None:
ns_name = namespace + (':' if namespace else '') + pattern.name
prev_callback = callbacks.get(ns_name)
if prev_callback:
if getattr(pattern.callback, 'can_url_perms', None) != \
getattr(prev_callback, 'can_url_perms', None):
raise RuntimeError(
"Found multiple URL patterns named %r with different "
"perms. If you want to decorate single view multiple "
"times with urlpatterns.url, add perms= option to the "
"last decorator only, it will apply to all." %
ns_name)
callbacks[ns_name] = pattern.callback
add_callbacks(urlresolvers.get_resolver(urlconf), '')
return callbacks
def __init__(self):
self._supported_languages = OrderedDict(settings.LANGUAGES)
self._is_language_prefix_patterns_used = False
for url_pattern in get_resolver(None).url_patterns:
if isinstance(url_pattern, LocaleRegexURLResolver):
self._is_language_prefix_patterns_used = True
break
def get_urls(namespaces=None):
"""
Load urlconf from settings.ROOT_URLCONF attribute
"""
root_resolver = get_resolver(None)
return get_url_patterns(root_resolver.url_patterns,
filter_namespaces=namespaces)
def is_language_prefix_patterns_used(self, request):
"""Returns `True` if the `LocaleRegexURLResolver` is used
at root level of the urlpatterns, else it returns `False`."""
for url_pattern in get_resolver(request.urlconf).url_patterns:
if isinstance(url_pattern, LocaleRegexURLResolver):
return True
return False
def _get_named_patterns():
"Returns list of (pattern-name, pattern) tuples"
resolver = urlresolvers.get_resolver(None)
patterns = sorted([(key, value[0][0][0])
for key, value in resolver.reverse_dict.items()
if isinstance(key, basestring)])
return patterns
