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 = long(path)
else:
object_id = long(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 = RegexURLResolver('^', 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 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 = long(path)
else:
object_id = long(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 = RegexURLResolver('^', 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 flatpage(request, url):
"""
Copy of a `flatpage` view from `django.contrib.flatpages`. Use our `FlatPage` model instead of django one.
"""
if not url.startswith('/'):
url = '/' + url
site_id = get_current_site(request).id
try:
f = get_object_or_404(FlatPage, url=url, sites=site_id)
except Http404:
try:
if not url.endswith('/') and settings.APPEND_SLASH:
url += '/'
f = get_object_or_404(FlatPage, url=url, sites=site_id)
return HttpResponsePermanentRedirect('%s/' % request.path)
else:
raise
except Http404:
# XXX: Temporary redirection of the old person URLs to the new URLs
resolver = RegexURLResolver(r'^/', HUMAN_PATTERNS)
match = resolver.resolve(url)
if Person.objects.filter(is_active=True, human__nickname=match.kwargs['slug']).exists():
return HttpResponsePermanentRedirect(urljoin('/people/person/', url[1:]))
raise
return render_flatpage(request, f)
def _resolve(self, path):
urlconf = settings.ROOT_URLCONF
resolver=RegexURLResolver(r'^/', urlconf)
view_function, func_args, func_kwargs = resolver.resolve(path)
module_name = view_function.__module__
func_name = view_function.func_name
return module_name, func_name, func_args, func_kwargs
def route(self, request, path_components):
if not self.live:
raise Http404
resolver = RegexURLResolver(r"^", self.app)
path = request.path[len(self.url):]
view, args, kwargs = resolver.resolve(path)
self._view = view
return (self, args, kwargs)
def route(self, request, path_components):
if not self.live:
raise Http404
resolver = RegexURLResolver(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 _get_view_and_args(path, request):
"""
Return the view at ``path`` and its named and positional arguments.
Django will raise a Resolver404 exception if ``path`` doesn't exist.
"""
# Let's use urlconf from request object, if available:
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
resolver = RegexURLResolver(r"^/", urlconf)
return resolver.resolve(path)
class HandlerResolver(object):
def __init__(self, conf):
self.resolver = RegexURLResolver(r'^', conf)
def resolve(self, update):
try:
resolver_match = self.resolver.resolve(update.message.text)
return resolver_match
except Resolver404:
raise HandlerNotFound("No handler configured for %s" % update.message.text)
def _get_view_and_args(path, request):
"""
Return the view at ``path`` and its named and positional arguments.
Django will raise a Resolver404 exception if ``path`` doesn't exist.
"""
# Let's use urlconf from request object, if available:
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
resolver = RegexURLResolver(r"^/", urlconf)
return resolver.resolve(path)
def thing_app(request, space_id, thing_id):
space = get_object_or_404(Space, pk=space_id)
template_module_name = 'template_2' # TODO hard coded for the mo
module_name = '%s.%s.application' % (os.path.basename(settings.TEMPLATE_APPS_DIR), template_module_name)
exec 'import %s as app_module' % module_name
app = app_module.Application()
resolver = RegexURLResolver(r'^/', app.urlpatterns)
base_path = reverse('sim.views.thing_app', kwargs={ 'space_id':space_id, 'thing_id':thing_id })
local_path = request.path[len(base_path) - 1:]
view_function = resolver.resolve(local_path)
return view_function[0](request)
class MultiviewTests(unittest.TestCase):
def setUp(self):
# Patterns with a "catch all" view (thing) at the end.
self.patterns_catchall = RegexURLResolver(
'^/',
patterns(
'',
multiurl(
url(r'^(\w+)/$', person, name='person'),
url(r'^(\w+)/$', place, name='place'),
url(r'^(\w+)/$', thing, name='thing'),
)))
# Patterns with no "catch all" - last view could still raise ContinueResolving.
self.patterns_no_fallthrough = RegexURLResolver(
'^/',
patterns(
'',
multiurl(
url(r'^(\w+)/$', person, name='person'),
url(r'^(\w+)/$', place, name='place'),
)))
def test_resolve_match_first(self):
m = self.patterns_catchall.resolve('/jane/')
response = m.func(request=None, *m.args, **m.kwargs)
self.assertEqual(response.content, b"Person: Jane Doe")
def test_resolve_match_middle(self):
m = self.patterns_catchall.resolve('/sf/')
response = m.func(request=None, *m.args, **m.kwargs)
self.assertEqual(response.content, b"Place: San Francisco")
def test_resolve_match_last(self):
m = self.patterns_catchall.resolve('/bacon/')
response = m.func(request=None, *m.args, **m.kwargs)
self.assertEqual(response.content, b"Thing: Bacon")
def test_resolve_match_faillthrough(self):
m = self.patterns_no_fallthrough.resolve('/bacon/')
with self.assertRaises(Resolver404):
m.func(request=None, *m.args, **m.kwargs)
def test_no_match(self):
with self.assertRaises(Resolver404):
self.patterns_catchall.resolve('/eggs/and/bacon/')
def test_reverse(self):
self.assertEqual('joe/',
self.patterns_catchall.reverse('person', 'joe'))
self.assertEqual('joe/',
self.patterns_catchall.reverse('place', 'joe'))
self.assertEqual('joe/',
self.patterns_catchall.reverse('thing', 'joe'))
with self.assertRaises(NoReverseMatch):
self.patterns_catchall.reverse('person')
with self.assertRaises(NoReverseMatch):
self.patterns_catchall.reverse('argh', 'xyz')
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:
raise Http404("No ct_id parameter, unable to find admin subclass for path '{0}'.".format(path))
real_admin = self._get_real_admin_by_ct(ct_id)
resolver = RegexURLResolver('^', real_admin.urls)
resolvermatch = resolver.resolve(path)
if not resolvermatch:
raise Http404("No match for path '{0}' in admin subclass.".format(path))
return resolvermatch.func(request, *resolvermatch.args, **resolvermatch.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 = RegexURLResolver(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 url(self, value):
"""
Return valid url or empty string.
"""
resolver = RegexURLResolver(r'^/', settings.ROOT_URLCONF)
checked = []
try:
while value not in checked:
checked.append(value)
if MACRO_RE.match(value):
if MACRO_RE.sub(MACRO_REPL, value):
raise ReplaceDone
else:
raise ReplaceFailed
scheme, authority, path, query, fragment = urlsplit(value)
if not scheme and not authority and not path:
raise ReplaceDone
if (scheme and scheme.lower() not in self.check_schemes) or\
(authority and authority.lower() not in self.check_sites):
raise ReplaceDone
try:
callback, callback_args, callback_kwargs = resolver.resolve(path)
except Exception:
raise ReplaceFailed
try:
try:
setting = self.views[callback]
except KeyError:
if self.check_unregistered:
data_from_view(path, query)
raise ReplaceDone
if setting.get('disable', False):
raise ReplaceFailed
obj = object_from_view(path, query, setting['context'])
path = macro(obj)
if setting.get('remove_query', False):
query = None
value = urljoin(None, None, path, query, fragment)
raise ReplaceDone
except ReplaceRedirect, redirect:
value = redirect.target
scheme, authority, path, query, fragment = urlsplit(value)
if scheme == 'http' and authority == 'testserver':
value = urljoin(None, None, path, query, fragment)
else:
class MultiviewTests(unittest.TestCase):
def setUp(self):
# Patterns with a "catch all" view (thing) at the end.
self.patterns_catchall = RegexURLResolver('^/', patterns('',
multiurl(
url(r'^(\w+)/$', person, name='person'),
url(r'^(\w+)/$', place, name='place'),
url(r'^(\w+)/$', thing, name='thing'),
)
))
# Patterns with no "catch all" - last view could still raise ContinueResolving.
self.patterns_no_fallthrough = RegexURLResolver('^/', patterns('',
multiurl(
url(r'^(\w+)/$', person, name='person'),
url(r'^(\w+)/$', place, name='place'),
)
))
def test_resolve_match_first(self):
m = self.patterns_catchall.resolve('/jane/')
response = m.func(request=None, *m.args, **m.kwargs)
self.assertEqual(response.content, b"Person: Jane Doe")
def test_resolve_match_middle(self):
m = self.patterns_catchall.resolve('/sf/')
response = m.func(request=None, *m.args, **m.kwargs)
self.assertEqual(response.content, b"Place: San Francisco")
def test_resolve_match_last(self):
m = self.patterns_catchall.resolve('/bacon/')
response = m.func(request=None, *m.args, **m.kwargs)
self.assertEqual(response.content, b"Thing: Bacon")
def test_resolve_match_faillthrough(self):
m = self.patterns_no_fallthrough.resolve('/bacon/')
with self.assertRaises(Resolver404):
m.func(request=None, *m.args, **m.kwargs)
def test_no_match(self):
with self.assertRaises(Resolver404):
self.patterns_catchall.resolve('/eggs/and/bacon/')
def test_reverse(self):
self.assertEqual('joe/', self.patterns_catchall.reverse('person', 'joe'))
self.assertEqual('joe/', self.patterns_catchall.reverse('place', 'joe'))
self.assertEqual('joe/', self.patterns_catchall.reverse('thing', 'joe'))
with self.assertRaises(NoReverseMatch):
self.patterns_catchall.reverse('person')
with self.assertRaises(NoReverseMatch):
self.patterns_catchall.reverse('argh', 'xyz')
def widget_view(self, request, app_label, widget_name, path):
name = '%s.%s' % (app_label, widget_name)
if name not in self._registry:
raise Http404
state = DashboardState.objects.get_for_user(request.user)
data = json.loads(state.data)
names = []
for column in data['columns']:
for row in column:
names.append(row['name'])
if name not in names:
raise Http404
widget = self._registry[name]
urls = widget.urls
if urls is None:
raise Http404
resolver = RegexURLResolver(r'^', _URLConfModule(urls))
callback, args, kwargs = resolver.resolve(path)
return callback(request, *args, **kwargs)
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:
raise Http404(
"No ct_id parameter, unable to find admin subclass for path '{0}'."
.format(path))
real_admin = self._get_real_admin_by_ct(ct_id)
resolver = RegexURLResolver('^', real_admin.urls)
resolvermatch = resolver.resolve(path)
if not resolvermatch:
raise Http404(
"No match for path '{0}' in admin subclass.".format(path))
return resolvermatch.func(request, *resolvermatch.args,
**resolvermatch.kwargs)
def subclass_view(self, request, path):
type = int(request.GET.get('type', 0))
if not type:
try:
pos = path.find('/')
if pos == -1:
object_id = long(path)
else:
object_id = long(path[0:pos])
except ValueError:
raise Http404("No type parameter, unable to find admin subclass for path '{0}'.".format(path))
type = self._get_type_by_object_id(object_id)
real_admin = self._get_real_admin(type)
resolver = RegexURLResolver('^', real_admin.urls)
resolvermatch = resolver.resolve(path)
if not resolvermatch:
raise Http404("No match for path '{0}' in admin subclass.".format(path))
return resolvermatch.func(request, *resolvermatch.args, **resolvermatch.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 = RegexURLResolver(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 lookup_root(urlconf):
urlconf_module, app_name, namespace = include(urlconf)
resolver = RegexURLResolver('^', urlconf_module, app_name=app_name, namespace=namespace)
return resolver.resolve('').func
def resolve_subpage(self, path):
"""
This finds a view method/function from a URL path.
"""
resolver = RegexURLResolver(r'^', self.get_subpage_urls())
return resolver.resolve(path)
def resolve_view(self, request):
urls = self.function_or_urlconf
resolver = RegexURLResolver(r"^/", urls)
return resolver.resolve(request.path_info)
def test_no_prefix_view_class(self):
resolver = RegexURLResolver('/', no_prefix_patterns)
view = resolver.resolve('/2/')[0]
response = view(None)
self.assertEqual(response, 'Success!')
def test_no__patterns(self):
resolver = RegexURLResolver('/', no_url_patterns)
view = resolver.resolve('/1/')[0]
response = view(None)
self.assertEqual(response, 'Success!')
def test_prefix_string(self):
resolver = RegexURLResolver('/', prefix_patterns)
view = resolver.resolve('/3/')[0]
response = view(None)
self.assertEqual(response, 'Success!')
def process_rest_request(message, urls=settings.ROOT_URLCONF):
try:
data = json.loads(message.content['text'])
except:
logger.debug("Error parsing JSON")
return False
if 'datatype' not in data or data['datatype'] != 'request':
return False
for i in ['url', 'method']:
if i not in data:
return False
def return_403(reason='Access denied'):
message.reply_channel.send({
"text": json.dumps({
'status_code': 403,
'reason': reason
})
})
return False
def return_404(reason='Not found'):
message.reply_channel.send({
"text": json.dumps({
'status_code': 404,
'reason': reason
})
})
return False
def return_500(reason='Internal server error'):
message.reply_channel.send({
"text": json.dumps({
'status_code': 500,
'reason': reason
})
})
return False
try:
resolver = RegexURLResolver(r'^/', urls)
except:
logger.exception("Something went wrong when constructing the urlresolver")
return return_500()
split_url = urlsplit(data['url'])
try:
callback, callback_args, callback_kwargs = resolver.resolve(split_url.path)
except:
logger.exception("No matches found for url %s", data['url'])
return return_404()
request = ChannelRestRequest(message, method=data['method'].upper())
request.path = split_url.path
if 'meta' in data:
request.META = data['meta']
if 'body' in data:
body_data = data['body'].encode('utf-8')
request._stream = six.BytesIO(body_data)
request.META['CONTENT_LENGTH'] = len(body_data)
request.META['QUERY_PARAMS'] = split_url.query
request.fix_meta()
if split_url.query:
request.GET.update(dict(parse_qsl(split_url.query)))
response = None
request_middleware = []
for middleware_path in settings.MIDDLEWARE_CLASSES:
if not middleware_path.startswith('django'):
mw_class = import_string(middleware_path)
try:
mw_instance = mw_class()
if hasattr(mw_instance, 'process_request'):
request_middleware.append(mw_instance.process_request)
except MiddlewareNotUsed as exc:
if settings.DEBUG:
if six.text_type(exc):
logger.debug('MiddlewareNotUsed(%r): %s', middleware_path, exc)
else:
logger.debug('MiddlewareNotUsed: %r', middleware_path)
continue
try:
for middleware_method in request_middleware:
response = middleware_method(request)
if response:
break
response = callback(request, *callback_args, **callback_kwargs)
except:
logger.exception("Something went wrong procesing the view.")
return return_500()
response.render()
response_packet = {
'datatype': data['datatype'],
'meta': dict(response.items()),
'status_code': response.status_code,
}
if response.content:
response_packet['body'] = response.content.decode('utf-8')
if hasattr(response, 'status_text'):
response_packet['reason'] = response.status_text
if 'message_id' in data:
response_packet['message_id'] = data['message_id']
message.reply_channel.send({"text": json.dumps(response_packet)})
return True
def resolve_subpage(self, path):
"""
This finds a view method/function from a URL path.
"""
resolver = RegexURLResolver(r'^', self.get_subpage_urls())
return resolver.resolve(path)
'''
def test_d(req):
return 'this is child url test page.'
child_urlpatterns = [
url(r'^d/$', test_d),
]
urlpatterns = [
url(r'^$', v_index), #url 创建RegexURLResolver对象
url(r'^blogs/$', v_blogs),
url(r'^news/$', v_news),
url(r'^test/', include(child_urlpatterns)),
]
resolvs = RegexURLResolver(r'^/', urlpatterns)
'''
# RegexURLResolver 的第二个参数同url的第二个参数 ，会根据类型进行不同处理,
# 当第二个参数类型是字符串时，会先进行导出之后,在提取urlpatterns属性
resolvs = RegexURLResolver(r'^/', 'app.root_url')
urls = ['/news/', '/blogs/', '/whoami/', '/', '/test/d/', 'a/b/c/d']
for url in urls:
try:
match = resolvs.resolve(url)
print('match {}'.format(url))
print(match.func(None))
except Exception as e:
print('not match {}'.format(url))
def process_rest_request(message, urls=settings.ROOT_URLCONF):
try:
data = json.loads(message.content['text'])
except:
logger.debug("Error parsing JSON")
return False
if 'datatype' not in data or data['datatype'] != 'request':
return False
for i in ['url', 'method']:
if i not in data:
return False
def return_403(reason='Access denied'):
message.reply_channel.send(
{"text": json.dumps({
'status_code': 403,
'reason': reason
})})
return False
def return_404(reason='Not found'):
message.reply_channel.send(
{"text": json.dumps({
'status_code': 404,
'reason': reason
})})
return False
def return_500(reason='Internal server error'):
message.reply_channel.send(
{"text": json.dumps({
'status_code': 500,
'reason': reason
})})
return False
try:
resolver = RegexURLResolver(r'^/', urls)
except:
logger.exception(
"Something went wrong when constructing the urlresolver")
return return_500()
split_url = urlsplit(data['url'])
try:
callback, callback_args, callback_kwargs = resolver.resolve(
split_url.path)
except:
logger.exception("No matches found for url %s", data['url'])
return return_404()
request = ChannelRestRequest(message, method=data['method'].upper())
request.path = split_url.path
if 'meta' in data:
request.META = data['meta']
if 'body' in data:
body_data = data['body'].encode('utf-8')
request._stream = six.BytesIO(body_data)
request.META['CONTENT_LENGTH'] = len(body_data)
request.META['QUERY_PARAMS'] = split_url.query
request.fix_meta()
if split_url.query:
request.GET.update(dict(parse_qsl(split_url.query)))
response = None
request_middleware = []
for middleware_path in settings.MIDDLEWARE_CLASSES:
if not middleware_path.startswith('django'):
mw_class = import_string(middleware_path)
try:
mw_instance = mw_class()
if hasattr(mw_instance, 'process_request'):
request_middleware.append(mw_instance.process_request)
except MiddlewareNotUsed as exc:
if settings.DEBUG:
if six.text_type(exc):
logger.debug('MiddlewareNotUsed(%r): %s',
middleware_path, exc)
else:
logger.debug('MiddlewareNotUsed: %r', middleware_path)
continue
try:
for middleware_method in request_middleware:
response = middleware_method(request)
if response:
break
response = callback(request, *callback_args, **callback_kwargs)
except:
logger.exception("Something went wrong procesing the view.")
return return_500()
response.render()
response_packet = {
'datatype': data['datatype'],
'meta': dict(response.items()),
'status_code': response.status_code,
}
if response.content:
response_packet['body'] = response.content.decode('utf-8')
if hasattr(response, 'status_text'):
response_packet['reason'] = response.status_text
if 'message_id' in data:
response_packet['message_id'] = data['message_id']
message.reply_channel.send({"text": json.dumps(response_packet)})
return True
def resolve(self, *args, **kwargs):
result = RegexURLResolver.resolve(self, *args, **kwargs)
if result:
result = list(result)
result[0] = self._decorate_with(result[0])
return result
def resolve_view(self, request):
urls = self.function_or_urlconf
resolver = RegexURLResolver(r"^/", urls)
return resolver.resolve(request.path_info)
