def subclass_view(self, request, path):
"""
Forward any request to a custom view of the real admin.
"""
ct_id = int(request.GET.get("ct_id", 0))
if not ct_id:
# See if the path started with an ID.
try:
pos = path.find("/")
if pos == -1:
object_id = int(path)
else:
object_id = int(path[0:pos])
except ValueError:
raise Http404(
"No ct_id parameter, unable to find admin subclass for path '{0}'."
.format(path))
ct_id = self.model.objects.values_list("polymorphic_ctype_id",
flat=True).get(pk=object_id)
real_admin = self._get_real_admin_by_ct(ct_id)
resolver = URLResolver("^", real_admin.urls)
resolvermatch = resolver.resolve(path) # May raise Resolver404
if not resolvermatch:
raise Http404(
"No match for path '{0}' in admin subclass.".format(path))
return resolvermatch.func(request, *resolvermatch.args,
**resolvermatch.kwargs)
def crud_impl(request, rest_path):
m = URLResolver(RegexPattern(r'^'), urlpatterns).resolve(rest_path)
return m.func(request=request,
model=model,
**all,
**kwargs[m.func.__name__],
**m.kwargs)
def _resolve_urlpatterns(self, urlpatterns, test_paths, allowed=None):
factory = APIRequestFactory()
try:
urlpatterns = format_suffix_patterns(urlpatterns, allowed=allowed)
except Exception:
self.fail(
"Failed to apply `format_suffix_patterns` on the supplied urlpatterns"
)
resolver = URLResolver(RegexPattern(r'^/'), urlpatterns)
for test_path in test_paths:
try:
test_path, expected_resolved = test_path
except (TypeError, ValueError):
expected_resolved = True
request = factory.get(test_path.path)
try:
callback, callback_args, callback_kwargs = resolver.resolve(
request.path_info)
except Resolver404:
callback, callback_args, callback_kwargs = (None, None, None)
if expected_resolved:
raise
except Exception:
self.fail("Failed to resolve URL: %s" % request.path_info)
if not expected_resolved:
assert callback is None
continue
assert callback_args == test_path.args
assert callback_kwargs == test_path.kwargs
def render(self, context):
"""
Render the view node
"""
if 'request' not in context:
return ""
request = context['request']
url_or_view = Variable(self.url_or_view).resolve(context)
try:
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
resolver = URLResolver(r'^/', urlconf)
view, args, kwargs = resolver.resolve(url_or_view)
# pylint: disable=bare-except
except:
view = get_callable(url_or_view)
args = [Variable(arg).resolve(context) for arg in self.args]
kwargs = {}
for key, value in self.kwargs.items():
kwargs[key] = Variable(value).resolve(context)
try:
if callable(view):
render_fnc = view(context['request'], *args, **kwargs).content.\
decode('unicode_escape')
return render_fnc
raise "%r is not callable" % view
# pylint: disable=bare-except
except:
if settings.DEBUG_PROPAGATE_EXCEPTIONS:
raise
return ""
def render(self, context):
if 'request' not in context:
return ""
request = context['request']
url_or_view = Variable(self.url_or_view).resolve(context)
try:
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
resolver = URLResolver(RegexPattern(r'^/'), urlconf)
view, args, kwargs = resolver.resolve(url_or_view)
except:
view = get_callable(url_or_view)
args = [Variable(arg).resolve(context) for arg in self.args]
kwargs = {}
for key, value in self.kwargs.items():
kwargs[key] = Variable(value).resolve(context)
try:
if callable(view):
return view(context['request'], *args,
**kwargs).content.decode(settings.DEFAULT_CHARSET)
raise "%r is not callable" % view
except:
if getattr(settings, 'TEMPLATE_DEBUG', False):
raise
return ""
def make_url_resolver(regex, urlpatterns):
try:
# Django 2.0
from django.urls.resolvers import RegexPattern
return URLResolver(RegexPattern(regex), urlpatterns)
except ImportError:
# Django < 2.0
return URLResolver(regex, urlpatterns)
def route(self, request, path_components):
if not self.live:
raise Http404
resolver = URLResolver(RegexPattern(r"^"), self.APP_PREFIX + self.app)
path = request.path[len(self.url):]
view, args, kwargs = resolver.resolve(path)
self._view = view
return (self, args, kwargs)
def process_resolver(resolver: URLResolver, injector: Injector) -> None:
if resolver.callback:
resolver.callback = wrap_fun(resolver.callback, injector)
for pattern in resolver.url_patterns:
if isinstance(pattern, URLPattern) and pattern.callback:
pattern.callback = wrap_fun(pattern.callback, injector)
elif isinstance(pattern, URLResolver):
process_resolver(pattern, injector)
if resolver._populated:
resolver._populate()
def _get_django_urlpatterns(json_urlpatterns):
"""
Parse JSON URLconf, and return a list of Django urlpatterns.
:param json_urlpatterns: list of JSON URLconf dicts
:return: list of Django URLResolver and URLPattern objects
"""
django_urlpatterns = []
for json_url in json_urlpatterns:
includes = json_url.get("includes")
if includes:
# Make a URLResolver
included_django_urlpatterns = _get_django_urlpatterns(includes)
isLocalePrefix = json_url.get("isLocalePrefix")
if isLocalePrefix:
# Make a LocalePrefixPattern.
# Custom sub-classes are allowed.
LocalePrefixPatternClass = locate(json_url.get("classPath"))
if not issubclass(LocalePrefixPatternClass,
LocalePrefixPattern):
raise ValueError(
f"Locale prefix class {json_url.get('classPath')} "
f"is not a subclass of LocalePrefixPattern")
django_url = URLResolver(LocalePrefixPatternClass(),
included_django_urlpatterns)
else:
# Make an include(...)
PatternClass, regex = _get_pattern_class_and_regex(json_url)
pattern = PatternClass(regex, is_endpoint=False)
django_url = URLResolver(
pattern,
included_django_urlpatterns,
app_name=json_url.get("app_name"),
namespace=json_url.get("namespace"),
)
else:
# Make a URLPattern
name = json_url.get("name")
PatternClass, regex = _get_pattern_class_and_regex(json_url)
pattern = PatternClass(regex, name=name, is_endpoint=True)
# Make a dummy view so the URL Pattern is valid.
# If this view is ever actually rendered, it will return 404.
# Note we're also ignoring the kwargs that can be added to url() definitions.
# These are not used to generate urls, they are just passed to the view.
django_url = URLPattern(pattern, Http404View.as_view(), name=name)
django_urlpatterns.append(django_url)
return django_urlpatterns
def get_resolver(cls):
if "_routablepage_urlresolver" not in cls.__dict__:
subpage_urls = cls.get_subpage_urls()
cls._routablepage_urlresolver = URLResolver(
RegexPattern(r"^/"), subpage_urls)
return cls._routablepage_urlresolver
def handle_message(self, message, bot_service):
"""
Process incoming message generating a response to the sender.
:param message: Generic message received from provider
:param bot_service: Service Integration
:type bot_service: IntegrationBot :class:`IntegrationBot <permabots.models.bot.IntegrationBot>`
.. note:: Message content will be extracted by IntegrationBot
"""
urlpatterns = []
state_context = {}
chat_state = bot_service.get_chat_state(message)
for handler in caching.get_or_set_related(self, 'handlers', 'response',
'request', 'target_state'):
if handler.enabled:
source_states = caching.get_or_set_related(
handler, 'source_states')
if chat_state:
state_context = chat_state.ctx
if not source_states or (chat_state and chat_state.state
in source_states):
urlpatterns.append(handler.urlpattern())
resolver = URLResolver(RegexPattern(r'^'), urlpatterns)
try:
resolver_match = resolver.resolve(
bot_service.message_text(message))
except Resolver404:
logger.warning("Handler not found for %s" % message)
else:
callback, callback_args, callback_kwargs = resolver_match
logger.debug("Calling callback:%s for message %s with %s" %
(callback, message, callback_kwargs))
text, keyboard, target_state, context = callback(
self,
message=message,
service=bot_service.identity,
state_context=state_context,
**callback_kwargs)
if target_state:
self.update_chat_state(bot_service, message, chat_state,
target_state, context)
keyboard = bot_service.build_keyboard(keyboard)
bot_service.send_message(bot_service.get_chat_id(message), text,
keyboard, message)
def get(self, request):
urls = []
resolver = URLResolver(RegexPattern(r'^/'), 'e_logs.business_logic.dictionaries.urls')
for url in filter(lambda x: isinstance(x[0], str), list(resolver.reverse_dict.items())):
link = '/api/bl/dicts/' + url[1][0][0][0]
urls.append({"title": url[0], "link": link, 'name':link.split('/')[-2]})
return JsonResponse(urls, safe=False)
class HandlerResolver(object):
def __init__(self, conf):
try:
self.resolver = RegexURLResolver(r'^', conf)
except NameError:
self.resolver = URLResolver(RegexPattern(r'^'), conf)
def resolve(self, update):
try:
resolver_match = self.resolver.resolve(update.message.text)
return resolver_match
except AttributeError:
resolver_match = self.resolver.resolve(update.callback_query.data)
return resolver_match
except Resolver404:
raise HandlerNotFound("No handler configured for %s" % update.message.text)
def recurse_patterns(path,
pattern_list,
page_id,
default_args=None,
nested=False):
"""
Recurse over a list of to-be-hooked patterns for a given path prefix
"""
newpatterns = []
for pattern in pattern_list:
app_pat = getattr(pattern, 'pattern', pattern).regex.pattern
# make sure we don't get patterns that start with more than one '^'!
app_pat = app_pat.lstrip('^')
path = path.lstrip('^')
regex = r'^%s%s' % (path,
app_pat) if not nested else r'^%s' % (app_pat)
if isinstance(pattern, URLResolver):
# include default_args
args = pattern.default_kwargs
if default_args:
args.update(default_args)
# see lines 243 and 236 of urlresolvers.py to understand the next line
urlconf_module = recurse_patterns(regex,
pattern.url_patterns,
page_id,
args,
nested=True)
# this is an 'include', recurse!
regex_pattern = RegexPattern(regex)
resolver = URLResolver(regex_pattern, urlconf_module,
pattern.default_kwargs, pattern.app_name,
pattern.namespace)
else:
# Re-do the URLPattern with the new regular expression
args = pattern.default_args
if default_args:
args.update(default_args)
regex_pattern = RegexPattern(regex,
name=pattern.name,
is_endpoint=True)
resolver = URLPattern(regex_pattern, pattern.callback, args,
pattern.name)
resolver.page_id = page_id
newpatterns.append(resolver)
return newpatterns
def get_resolver(cls):
if '_routablepage_urlresolver' not in cls.__dict__:
subpage_urls = cls.get_subpage_urls()
if django.VERSION >= (2, 0):
cls._routablepage_urlresolver = URLResolver(
RegexPattern(r'^/'), subpage_urls)
else: # Django 1.11 fallback
cls._routablepage_urlresolver = RegexURLResolver(
r'^/', subpage_urls)
return cls._routablepage_urlresolver
def test_get_urls():
"""
Calling get_urls returns an URLConf with the correctly formed paths pointing to
their corresponding views
"""
registry = Registry()
mock_request_handler = lambda request: None # noqa: E731
class TestIntegration(BaseIntegration):
name = "some-integration"
def get_urls(self):
return [path("v1/path/", mock_request_handler)]
registry.register(TestIntegration)
urlconf = registry.get_urls()
resolver = URLResolver(RegexPattern(r"^/"), urlconf)
valid_paths = ["/api/integrations/some-integration/v1/path/"]
for valid_path in valid_paths:
resolver_match = resolver.resolve(valid_path)
assert resolver_match.func == mock_request_handler
def i18n_patterns(*urls, prefix_default_language=True):
"""Add the language code prefix to every URL pattern within this function.
This may only be used in the root URLconf, not in an included URLconf.
"""
if not settings.USE_I18N:
return list(urls)
return [
URLResolver(
ActiveLocalePrefixPattern(prefix_default_language=prefix_default_language),
list(urls),
)
]
def get_url_resolver(self):
"""
Access the URL resolver of the page type.
"""
if self._url_resolver is None:
if self.urls is None:
return None
elif isinstance(self.urls, string_types):
mod = import_module(self.urls)
if not hasattr(mod, 'urlpatterns'):
raise ImproperlyConfigured("URLConf `{0}` has no urlpatterns attribute".format(self.urls))
patterns = getattr(mod, 'urlpatterns')
elif isinstance(self.urls, (list, tuple)):
patterns = self.urls
else:
raise ImproperlyConfigured("Invalid value for '{0}.urls', must be string, list or tuple.".format(self.__class__.__name__))
if django.VERSION > (2, 0):
self._url_resolver = URLResolver(RegexPattern(r'^/'), patterns)
else:
self._url_resolver = URLResolver(r'^/', patterns)
return self._url_resolver
def i18n_patterns(*urls, prefix_default_language=True):
"""
Replacement for django.conf.urls.i18_patterns that uses ISO3166LocalePrefixPattern
instead of django.urls.resolvers.LocalePrefixPattern.
"""
if not settings.USE_I18N:
return list(urls)
return [
URLResolver(
ISO3166LocalePrefixPattern(
prefix_default_language=prefix_default_language),
list(urls),
)
]
def execute(self):
self.load_all_endpoints(
URLResolver(r'^/', settings.ROOT_URLCONF).url_patterns)
for url_pattern, lookup_str, url_name in self.all_patterns:
if not self.app_names or self.is_url_inside_specified_app(
lookup_str):
self.create_tests_for_endpoint(url_pattern, url_name)
if self.disable_migrations:
self._disable_native_migrations()
self._set_fixture_path()
call_command_kwargs = self._get_call_command_kwargs()
call_command('test', 'django_smoke_tests', **call_command_kwargs)
def test_export_custom_locale_prefix_pattern_class(mock_urlconf_module):
mock_urlconf_module.urlpatterns = [
URLResolver(CustomLocalePrefixPattern(),
[url(r"^$", View.as_view(), name="index")])
]
assert export_urlconf.as_json("mock_urlconf_module") == [{
"isLocalePrefix":
True,
"classPath":
"tests.django_urlconf_export.test_export_urlconf.CustomLocalePrefixPattern",
"includes": [{
"regex": "^$",
"name": "index"
}],
}]
def i18n_patterns(*urls):
"""
Add the language code prefix to every URL pattern within this function.
This may only be used in the root URLconf, not in an included URLconf.
NOTE: Modified from i18n_patterns in Django 2.2 / 3.0, see:
https://github.com/django/django/blob/3.0/django/conf/urls/i18n.py#L8-L20
Modifications:
- Raises ImproperlyConfigured if settings.USE_I18N is False
- Forces prefix_default_language to True, so urls always include the locale
- Does not accept prefix_default_language as a kwarg, due to the above
- Uses our custom URL prefix pattern, to support our locale codes
"""
if not settings.USE_I18N:
raise ImproperlyConfigured("Kuma requires settings.USE_I18N to be True.")
return [URLResolver(KumaLocalePrefixPattern(), list(urls))]
def decorate_pattern(self, pattern):
if isinstance(pattern, URLResolver):
decorated = URLResolver(
pattern.pattern,
DecoratedPatterns(pattern.urlconf_module, self.decorators),
pattern.default_kwargs,
pattern.app_name,
pattern.namespace,
)
else:
callback = pattern.callback
for decorator in reversed(self.decorators):
callback = decorator(callback)
decorated = URLPattern(
pattern.pattern,
callback,
pattern.default_args,
pattern.name,
)
return decorated
def _path(route, view, kwargs=None, name=None, Pattern=None):
"""Copied from django.urls.conf (Django 2.0) and modified to return our Resolver/Matcher."""
if isinstance(view, (list, tuple)):
# For include(...) processing.
pattern = Pattern(route, is_endpoint=False)
urlconf_module, app_name, namespace = view
return URLResolver(
pattern,
urlconf_module,
kwargs,
app_name=app_name,
namespace=namespace,
)
elif callable(view):
pattern = Pattern(route, name=name, is_endpoint=True)
return LocaleURLPattern(pattern, view, kwargs, name)
else:
raise TypeError(
'view must be a callable or a list/tuple in the case of include().'
)
def get_url_info(pattern, parent_pattern, parent_namespace):
login_required, permission_required = get_perms(pattern.callback)
if parent_namespace and not parent_namespace == 'None':
full_name = f'{parent_namespace}:{pattern.name}'
else:
full_name = pattern.name
urls_list.append({
'url_name':
full_name,
'url_url':
URLResolver._join_route(str(parent_pattern),
str(pattern.pattern)),
'view_name':
pattern.callback.__name__,
'view_path':
pattern.lookup_str,
'login_required':
login_required,
'permission_required':
permission_required,
})
class AppPageMixin:
@property
def url_config(self):
raise NotImplementedError('url_config')
def reverse(self, name, *args, **kwargs):
sub_url = self._apppage_url_resolver.reverse(name, *args, **kwargs)
return self.url + sub_url.lstrip('/')
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._apppage_url_resolver = URLResolver(
RegexPattern(r'^{}'.format(self.url)), self.url_config)
def route(self, request, path_components):
# url config takes precedence over normal wagtail routing
try:
view, args, kwargs = self._apppage_url_resolver.resolve(
request.path)
except Resolver404:
return super().route(request, path_components)
else:
return RouteResult(self, args=(view, args, kwargs))
def serve(self, request, view=None, args=None, kwargs=None):
if args is None:
args = []
if kwargs is None:
kwargs = {}
if view is None:
return super().serve(request, *args, **kwargs)
request.parent_page = self
# if this is a class-based view, we'll make the parent page available as an attribute as well
if getattr(view, 'view_class', None):
view.view_class.parent_page = self
return view(request, *args, **kwargs)
def __init__(self, conf):
try:
self.resolver = RegexURLResolver(r'^', conf)
except NameError:
self.resolver = URLResolver(RegexPattern(r'^'), conf)
def get_resolver(url, url_config):
return URLResolver(RegexPattern(r'^{}'.format(url)), url_config)
def tenant_patterns(*urls):
"""
Add the tenant prefix to every URL pattern within this function.
This may only be used in the root URLconf, not in an included URLconf.
"""
return [URLResolver(TenantPrefixPattern(), list(urls))]
def get_resolver(patterns=None):
patterns = patterns or redirectpatterns
return URLResolver(RegexPattern(r"^/"), patterns)
