def setUp(self): from django.core.urlresolvers import RegexURLResolver urlconf = "regressiontests.urlpatterns_reverse.urls_error_handlers" urlconf_callables = "regressiontests.urlpatterns_reverse.urls_error_handlers_callables" self.resolver = RegexURLResolver(r"^$", urlconf) self.callable_resolver = RegexURLResolver(r"^$", urlconf_callables)
def get_resolver(cls): if cls._resolver: return cls._resolver pats = [] for rule in Rule.on_site.all(): view = redirect_to params = {} if rule.target_view: view = rule.target_view if rule.target_params: params = dict(QueryDict(rule.target_params, mutable=True).items()) if rule.target_url_name: params = {'url': reverse(rule.target_url_name, kwargs=params)} if rule.target_url: params = {'url': rule.target_url} if rule.redirection_type: params['status_code'] = rule.redirection_type pats.append((r'^%s$' % rule.pattern, view, params)) urlpatterns = patterns('', *pats) resolver = RegexURLResolver(r'^/', urlpatterns) resolver.app_name = 'redirector' cls._resolver = resolver return resolver
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 recurse_patterns(path, pattern_list, page_id, default_args=None): """ Recurse over a list of to-be-hooked patterns for a given path prefix """ newpatterns = [] for pattern in pattern_list: app_pat = 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 isinstance(pattern, RegexURLResolver): # this is an 'include', recurse! resolver = RegexURLResolver(regex, 'cms_appresolver', pattern.default_kwargs, pattern.app_name, pattern.namespace) resolver.page_id = page_id # 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 resolver._urlconf_module = recurse_patterns(regex, pattern.url_patterns, page_id, args) else: # Re-do the RegexURLPattern with the new regular expression args = pattern.default_args if default_args: args.update(default_args) resolver = RegexURLPattern(regex, pattern.callback, args, pattern.name) resolver.page_id = page_id newpatterns.append(resolver) return newpatterns
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 recurse_patterns(path, pattern_list, page_id): """ Recurse over a list of to-be-hooked patterns for a given path prefix """ newpatterns = [] for pattern in pattern_list: app_pat = pattern.regex.pattern if app_pat.startswith('^'): app_pat = app_pat[1:] regex = r'^%s%s' % (path, app_pat) if isinstance(pattern, RegexURLResolver): # this is an 'include', recurse! resolver = RegexURLResolver(regex, 'cms_appresolver', pattern.default_kwargs, pattern.app_name, pattern.namespace) # This is a bit hacky, usually a RegexURLResolver uses the urlconf_name # to resolve URLs, but we just override the url_patterns... resolver.page_id = page_id resolver.url_patterns = recurse_patterns(regex, pattern.url_patterns, page_id) else: # Re-do the RegexURLPattern with the new regular expression resolver = RegexURLPattern(regex, pattern.callback, pattern.default_args, pattern.name) resolver.page_id = page_id newpatterns.append(resolver) return newpatterns
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 get_resolver(cls): if cls._resolver: return cls._resolver pats = [] for rule in Rule.on_site.all(): view = redirect_to params = {} if rule.target_view: view = rule.target_view if rule.target_params: params = dict( QueryDict(rule.target_params, mutable=True).items()) if rule.target_url_name: params = {'url': reverse(rule.target_url_name, kwargs=params)} if rule.target_url: params = {'url': rule.target_url} if rule.redirection_type: params['status_code'] = rule.redirection_type pats.append((r'^%s$' % rule.pattern, view, params)) urlpatterns = patterns('', *pats) resolver = RegexURLResolver(r'^/', urlpatterns) resolver.app_name = 'redirector' cls._resolver = resolver return resolver
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)
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)
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 get_resolver(cls): if '_routablepage_urlresolver' not in cls.__dict__: subpage_urls = cls.get_subpage_urls() cls._routablepage_urlresolver = RegexURLResolver( r'^/', subpage_urls) return cls._routablepage_urlresolver
def load_app(app, root_module=None): module = None try: module = loadModule(app + '.rpc') except ImportError as err: print "**** failed to load {0}.rpc! ****".format(app) print "**** missing dependencies ****" print "**** {0} ****".format(err) except SyntaxError as serr: print "\t{0}: ".format(app), print "fail" print "Exception in user code:" print '-' * 60 traceback.print_exc(file=sys.stdout) print '-' * 60 except Exception as err: print "\t{0}: ".format(app), print "fail" print "Exception in user code:" print '-' * 60 traceback.print_exc(file=sys.stdout) print '-' * 60 if module: if not root_module: root_module = module urls = RegexURLResolver( '^' + getattr(module, 'URL_PREFIX', app.split('.')[-1]) + "/", root_module) # print urls.url_patterns # print "" urlpatterns.append(urls) return module
def test_omit_parameters(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer def post(self, request, *args, **kwargs): """ My post view with custom post parameters --- omit_parameters: - form parameters: - name: name type: string required: true """ return super(SerializedAPI, self).post(request, *args, **kwargs) class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') parser = introspector.get_yaml_parser() params = parser.discover_parameters(introspector) self.assertEqual(0, len(params))
def test_custom_response_class(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer def post(self, request, *args, **kwargs): """ --- type: name: required: true type: string url: required: false type: url """ return super(SerializedAPI, self).post(request, *args, **kwargs) class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') parser = introspector.get_yaml_parser() generator = DocumentationGenerator() serializer = generator._get_method_serializer(introspector) response_class = generator._get_method_response_type( parser, serializer, class_introspector, introspector) self.assertEqual(response_class, 'SerializedAPIPostResponse') self.assertEqual(serializer, None) self.assertIn('SerializedAPIPostResponse', generator.explicit_response_types)
def url(regex, view, kwargs=None, name=None, prefix=''): if isinstance(view, (list,tuple)): 如果是 list 或者 tuple # For include(...) processing. 处理包含 include(...) urlconf_module, app_name, namespace = view # 此处返回 RegexURLResolver, 区分下面返回 RegexURLPattern return RegexURLResolver(regex, urlconf_module, kwargs, app_name=app_name, namespace=namespace)
def test_response_messages(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer def post(self, request, *args, **kwargs): """ --- responseMessages: - code: 403 message: Not authorized. - code: 404 message: Not found. """ return super(SerializedAPI, self).post(request, *args, **kwargs) class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') parser = introspector.get_yaml_parser() messages = parser.get_response_messages() self.assertEqual(2, len(messages)) self.assertEqual(messages[0]['message'], 'Not authorized.') self.assertEqual(messages[1]['message'], 'Not found.')
def _get_plugin_patterns(self): log.debug("PluginURLPattern._get_plugin_patterns") from pylucid_project.apps.pylucid.models.pluginpage import PluginPage from pylucid_project.apps.pylucid.models.pagemeta import PageMeta from pylucid_project.apps.pylucid.models.pagetree import PageTree plugin_pages = PluginPage.objects.all() all_page_metas = PageMeta.objects.filter( pagetree__page_type=PageTree.PLUGIN_TYPE) pattern_list = [] for plugin_page in plugin_pages: plugin_instance = plugin_page.get_plugin() page_metas = all_page_metas.filter(pagetree=plugin_page.pagetree) for page_meta in page_metas: url_prefix = page_meta.get_absolute_url() log.debug("add patterns for url prefix: %r" % url_prefix) prefixed_urlpatterns = plugin_instance.get_prefix_urlpatterns( url_prefix, plugin_page.urls_filename) log_urls(urlpatterns=prefixed_urlpatterns) pattern_list += prefixed_urlpatterns debug_log_urls(pattern_list) log_urls(urlpatterns=pattern_list) plugin_patterns = RegexURLResolver(r'', pattern_list) return plugin_patterns
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 include_urlpatterns(regex, module): """ Usage: # in top-level module code: urlpatterns = include_urlpatterns(r'^profile/', 'apps.myapp.views.profile') """ return [RegexURLResolver(regex, module)]
def test_build_body_parameters(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') params = introspector.build_body_parameters() self.assertEqual('CommentSerializer', params['name'])
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 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:
def test_build_form_parameters(self): class SerializedAPI(ListCreateAPIView): serializer_class = CommentSerializer class_introspector = ViewSetIntrospector(SerializedAPI, '/', RegexURLResolver(r'^/$', '')) introspector = APIViewMethodIntrospector(class_introspector, 'POST') params = introspector.build_form_parameters() self.assertEqual(len(CommentSerializer().get_fields()), len(params))
def test_no_urls_exception(self): """ RegexURLResolver should raise an exception when no urlpatterns exist. """ resolver = RegexURLResolver(r'^$', self.urls) self.assertRaisesMessage(ImproperlyConfigured, "The included urlconf regressiontests.urlpatterns_reverse.no_urls "\ "doesn't have any patterns in it", getattr, resolver, 'url_patterns')
def register_url_resolver(self, app): # Install module URL resolver # @todo: Legacy django part? try: mr = self.urlresolvers[app.module, None] except KeyError: mr = patterns("") self.urlpatterns += [RegexURLResolver("^%s/" % app.module, mr, namespace=app.module)] self.urlresolvers[app.module, None] = mr # Install application URL resolver try: ar = self.urlresolvers[app.module, app.app] except KeyError: ar = patterns("") mr += [RegexURLResolver("^%s/" % app.app, ar, namespace=app.app)] self.urlresolvers[app.module, app.app] = ar return ar
def resolver(self, request): """ Returns a RegexURLResolver for the request's urlconf. If the request does not have a urlconf object, then the default of settings.ROOT_URLCONF is used. """ urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF) return RegexURLResolver(r'^/', urlconf)
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 get_subresolver(view_class, path=None): """ Create a subresolver for an ApplicationView Resolver will have path as base path/regex. """ path = r'' if path is None else r'^{}/'.format(path) return RegexURLResolver(path, urlconf_name=view_class.urlconf_name, namespace=view_class.namespace, app_name=view_class.app_name)
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 = 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, RegexURLResolver): # include default_args args = pattern.default_kwargs if default_args: args.update(default_args) if DJANGO_1_8: # this is an 'include', recurse! resolver = RegexURLResolver(regex, 'cms_appresolver', pattern.default_kwargs, pattern.app_name, pattern.namespace) # see lines 243 and 236 of urlresolvers.py to understand the next line resolver._urlconf_module = recurse_patterns( regex, pattern.url_patterns, page_id, args, nested=True) else: # 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! resolver = RegexURLResolver(regex, urlconf_module, pattern.default_kwargs, pattern.app_name, pattern.namespace) resolver.page_id = page_id else: # Re-do the RegexURLPattern with the new regular expression args = pattern.default_args if default_args: args.update(default_args) resolver = RegexURLPattern(regex, pattern.callback, args, pattern.name) resolver.page_id = page_id newpatterns.append(resolver) return newpatterns
class ErrorHandlerResolutionTests(TestCase): """Tests for handler400, handler404 and handler500""" def setUp(self): urlconf = 'urlpatterns_reverse.urls_error_handlers' urlconf_callables = 'urlpatterns_reverse.urls_error_handlers_callables' self.resolver = RegexURLResolver(r'^$', urlconf) self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables) def test_named_handlers(self): handler = (empty_view, {}) self.assertEqual(self.resolver.resolve_error_handler(400), handler) self.assertEqual(self.resolver.resolve_error_handler(404), handler) self.assertEqual(self.resolver.resolve_error_handler(500), handler) def test_callable_handers(self): handler = (empty_view, {}) self.assertEqual(self.callable_resolver.resolve_error_handler(400), handler) self.assertEqual(self.callable_resolver.resolve_error_handler(404), handler) self.assertEqual(self.callable_resolver.resolve_error_handler(500), handler)
def test_no_urls_exception(self): """ RegexURLResolver should raise an exception when no urlpatterns exist. """ resolver = RegexURLResolver(r'^$', settings.ROOT_URLCONF) self.assertRaisesMessage(ImproperlyConfigured, "The included urlconf 'urlpatterns_reverse.no_urls' does not " "appear to have any patterns in it. If you see valid patterns in " "the file then the issue is probably caused by a circular import.", getattr, resolver, 'url_patterns')
def resolver(request): """ Returns a RegexURLResolver for the request's urlconf. If the request does not have a urlconf object, then the default of settings.ROOT_URLCONF is used. """ from django.conf import settings urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF) return RegexURLResolver(r"^/", urlconf)
def ajax_url(regex, view, ajax_name, default=None, group=None, kwargs=None): if isinstance(view, (list, tuple)): urlconf_module, app_name, namespace = view AjaxTracker.Instance().add_ajax_url(regex, ajax_name, default, group) return RegexURLResolver(regex, urlconf_module, kwargs, app_name=app_name, namespace=namespace) if isinstance(view, six.string_types): raise ImproperlyConfigured('Invalid view specified (%s). Are you passing the callable?' % view) AjaxTracker.Instance().add_ajax_url(regex, ajax_name, default, group) return RegexURLPattern(regex, view, kwargs, ajax_name)
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)
class ErrorHandlerResolutionTests(SimpleTestCase): """Tests for handler400, handler404 and handler500""" def setUp(self): urlconf = 'urlpatterns_reverse.urls_error_handlers' urlconf_callables = 'urlpatterns_reverse.urls_error_handlers_callables' self.resolver = RegexURLResolver(r'^$', urlconf) self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables) def test_named_handlers(self): handler = (empty_view, {}) self.assertEqual(self.resolver.resolve_error_handler(400), handler) self.assertEqual(self.resolver.resolve_error_handler(404), handler) self.assertEqual(self.resolver.resolve_error_handler(500), handler) def test_callable_handers(self): handler = (empty_view, {}) self.assertEqual(self.callable_resolver.resolve_error_handler(400), handler) self.assertEqual(self.callable_resolver.resolve_error_handler(404), handler) self.assertEqual(self.callable_resolver.resolve_error_handler(500), handler)
class ErrorHandlerResolutionTests(TestCase): """Tests for handler404 and handler500""" def setUp(self): from django.core.urlresolvers import RegexURLResolver urlconf = 'regressiontests.urlpatterns_reverse.urls_error_handlers' urlconf_callables = 'regressiontests.urlpatterns_reverse.urls_error_handlers_callables' self.resolver = RegexURLResolver(r'^$', urlconf) self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables) def test_named_handlers(self): from .views import empty_view handler = (empty_view, {}) self.assertEqual(self.resolver.resolve404(), handler) self.assertEqual(self.resolver.resolve500(), handler) def test_callable_handers(self): from .views import empty_view handler = (empty_view, {}) self.assertEqual(self.callable_resolver.resolve404(), handler) self.assertEqual(self.callable_resolver.resolve500(), handler)
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)
class ErrorHandlerResolutionTests(TestCase): """Tests for handler404 and handler500""" def setUp(self): from django.core.urlresolvers import RegexURLResolver urlconf = 'regressiontests.urlpatterns_reverse.urls_error_handlers' urlconf_callables = 'regressiontests.urlpatterns_reverse.urls_error_handlers_callables' self.resolver = RegexURLResolver(r'^$', urlconf) self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables) def test_named_handlers(self): from views import empty_view handler = (empty_view, {}) self.assertEqual(self.resolver.resolve404(), handler) self.assertEqual(self.resolver.resolve500(), handler) def test_callable_handers(self): from views import empty_view handler = (empty_view, {}) self.assertEqual(self.callable_resolver.resolve404(), handler) self.assertEqual(self.callable_resolver.resolve500(), handler)
def url(regex, view, kwargs=None, name=None, prefix=''): if isinstance(view, (list, tuple)): # For include(...) processing. urlconf_module, app_name, namespace = view return RegexURLResolver(regex, urlconf_module, kwargs, app_name=app_name, namespace=namespace) else: if isinstance(view, six.string_types): if not view: raise ImproperlyConfigured('Empty URL pattern view name not permitted (for pattern %r)' % regex) if prefix: view = prefix + '.' + view return RegexURLPattern(regex, view, kwargs, name)
def handle(self, *args, **options): if len(args) != 0: raise CommandError("Command doesn't accept any arguments") self.excluded_paths = options.get('excluded_paths') if not self.excluded_paths: self.excluded_paths = [] # Walking through all urls, starting from the root UrlConf urlconf = settings.ROOT_URLCONF rootresolver = RegexURLResolver(r'^/', urlconf) self._walk_urlresolver("/", rootresolver)
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 recurse_patterns(path, pattern_list, page_id): """ Recurse over a list of to-be-hooked patterns for a given path prefix """ newpatterns = [] for pattern in pattern_list: app_pat = pattern.regex.pattern if app_pat.startswith('^'): app_pat = app_pat[1:] regex = r'^%s%s' % (path, app_pat) if isinstance(pattern, RegexURLResolver): # this is an 'include', recurse! resolver = RegexURLResolver(regex, 'cms_appresolver', pattern.default_kwargs, pattern.app_name, pattern.namespace) resolver.page_id = page_id # see lines 243 and 236 of urlresolvers.py to understand the next line resolver._urlconf_module = recurse_patterns(regex, pattern.url_patterns, page_id) else: # Re-do the RegexURLPattern with the new regular expression resolver = RegexURLPattern(regex, pattern.callback, pattern.default_args, pattern.name) resolver.page_id = page_id newpatterns.append(resolver) return newpatterns
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 resolve_view(self, request): urls = self.function_or_urlconf resolver = RegexURLResolver(r"^/", urls) return resolver.resolve(request.path_info)
from django.contrib.sites.models import Site from django.contrib.auth.models import User from django.core.urlresolvers import reverse, RegexURLResolver from django.test import TestCase import waiter from waiter.apis.twitter import TwitterMenu import mox import urllib import random import oauth2 from django.utils import simplejson test_class = TestCase try: resolver = RegexURLResolver(r'^/', settings.ROOT_URLCONF) resolver.resolve404() from django.template.loader import get_template from django.template import TemplateDoesNotExist try: get_template('404.html') except TemplateDoesNotExist: test_class = object print """ *** bluebird.tests.views.py *** To run these tests you must define a 404.html in one of your template directories. """.strip() print "*"*80 raw_input("Press enter to continue: ") except AttributeError:
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 reverse_subpage(self, name, *args, **kwargs): """ This method does the same job as Djangos' built in "urlresolvers.reverse()" function for subpage urlconfs. """ resolver = RegexURLResolver(r'^', self.get_subpage_urls()) return self.url + resolver.reverse(name, *args, **kwargs)
def setUp(self): urlconf = 'urlpatterns_reverse.urls_error_handlers' urlconf_callables = 'urlpatterns_reverse.urls_error_handlers_callables' self.resolver = RegexURLResolver(r'^$', urlconf) self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables)
def __init__(self, conf): self.resolver = RegexURLResolver(r'^', conf)
def setUp(self): from django.core.urlresolvers import RegexURLResolver urlconf = 'urlpatterns_reverse.urls_error_handlers' urlconf_callables = 'urlpatterns_reverse.urls_error_handlers_callables' self.resolver = RegexURLResolver(r'^$', urlconf) self.callable_resolver = RegexURLResolver(r'^$', urlconf_callables)
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