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 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 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 _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
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 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 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 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
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)