cms.appresolver: 130 total statements, 0.0% covered

Generated: Wed 2013-03-13 10:33 CET

Source file: /media/Envs/Envs/filer-gallery/lib/python2.7/site-packages/cms/appresolver.py

Stats: 0 executed, 120 missed, 10 excluded, 79 ignored

1. # -*- coding: utf-8 -*-
2. from cms.apphook_pool import apphook_pool
3. from cms.utils.moderator import get_page_queryset
5. from django.conf import settings
6. from django.conf.urls.defaults import patterns
7. from django.contrib.sites.models import Site
8. from django.core.exceptions import ImproperlyConfigured
9. from django.core.urlresolvers import RegexURLResolver, Resolver404, reverse, \
10. RegexURLPattern
11. from django.db.models import Q
12. from django.utils.importlib import import_module
14. APP_RESOLVERS = []
16. def clear_app_resolvers():
17. global APP_RESOLVERS
18. APP_RESOLVERS = []
20. def applications_page_check(request, current_page=None, path=None):
21. """Tries to find if given path was resolved over application.
22. Applications have higher priority than other cms pages.
23. """
24. if current_page:
25. return current_page
26. if path is None:
27. # We should get in this branch only if an apphook is active on /
28. # This removes the non-CMS part of the URL.
29. path = request.path.replace(reverse('pages-root'), '', 1)
30. # check if application resolver can resolve this
31. for resolver in APP_RESOLVERS:
32. try:
33. page_id = resolver.resolve_page_id(path)
34. # yes, it is application page
35. if settings.CMS_MODERATOR:
36. page = get_page_queryset(request).get(Q(id=page_id) | Q(publisher_draft=page_id))
37. else:
38. page = get_page_queryset(request).get(id=page_id)
39. # If current page was matched, then we have some override for content
40. # from cms, but keep current page. Otherwise return page to which was application assigned.
41. return page
42. except Resolver404:
43. # Raised if the page is not managed by an apphook
44. pass
45. return None
47. class AppRegexURLResolver(RegexURLResolver):
48. page_id = None
49. url_patterns = None
51. def resolve_page_id(self, path):
52. """Resolves requested path similar way how resolve does, but instead
53. of return callback,.. returns page_id to which was application
54. assigned.
55. """
56. tried = []
57. match = self.regex.search(path)
58. if match:
59. new_path = path[match.end():]
60. for pattern in self.url_patterns:
61. try:
62. sub_match = pattern.resolve(new_path)
63. except Resolver404, e:
64. if 'tried' in e.args[0]:
65. tried.extend([(pattern.regex.pattern + ' ' + t) for t in e.args[0]['tried']])
66. elif 'path' in e.args[0]:
67. tried.extend([(pattern.regex.pattern + ' ' + t) for t in e.args[0]['path']])
68. else:
69. if sub_match:
70. return pattern.page_id
71. tried.append(pattern.regex.pattern)
72. raise Resolver404, {'tried': tried, 'path': new_path}
75. def recurse_patterns(path, pattern_list, page_id):
76. """
77. Recurse over a list of to-be-hooked patterns for a given path prefix
78. """
79. newpatterns = []
80. for pattern in pattern_list:
81. app_pat = pattern.regex.pattern
82. # make sure we don't get patterns that start with more than one '^'!
83. app_pat = app_pat.lstrip('^')
84. path = path.lstrip('^')
85. regex = r'^%s%s' % (path, app_pat)
86. if isinstance(pattern, RegexURLResolver):
87. # this is an 'include', recurse!
88. resolver = RegexURLResolver(regex, 'cms_appresolver',
89. pattern.default_kwargs, pattern.app_name, pattern.namespace)
90. resolver.page_id = page_id
91. # see lines 243 and 236 of urlresolvers.py to understand the next line
92. resolver._urlconf_module = recurse_patterns(regex, pattern.url_patterns, page_id)
93. else:
94. # Re-do the RegexURLPattern with the new regular expression
95. resolver = RegexURLPattern(regex, pattern.callback,
96. pattern.default_args, pattern.name)
97. resolver.page_id = page_id
98. newpatterns.append(resolver)
99. return newpatterns
101. def _flatten_patterns(patterns):
102. flat = []
103. for pattern in patterns:
104. if isinstance(pattern, RegexURLResolver):
105. flat += _flatten_patterns(pattern.url_patterns)
106. else:
107. flat.append(pattern)
108. return flat
110. def get_app_urls(urls):
111. for urlconf in urls:
112. if isinstance(urlconf, basestring):
113. mod = import_module(urlconf)
114. if not hasattr(mod, 'urlpatterns'):
115. raise ImproperlyConfigured(
116. "URLConf `%s` has no urlpatterns attribute" % urlconf)
117. yield getattr(mod, 'urlpatterns')
118. else:
119. yield urlconf
122. def get_patterns_for_title(path, title):
123. """
124. Resolve the urlconf module for a path+title combination
125. Returns a list of url objects.
126. """
127. app = apphook_pool.get_apphook(title.application_urls)
128. patterns = []
129. for pattern_list in get_app_urls(app.urls):
130. if path and not path.endswith('/'):
131. path += '/'
132. page_id = title.page.id
133. patterns += recurse_patterns(path, pattern_list, page_id)
134. patterns = _flatten_patterns(patterns)
135. return patterns
138. def get_app_patterns():
139. """
140. Get a list of patterns for all hooked apps.
142. How this works:
144. By looking through all titles with an app hook (application_urls) we find all
145. urlconf modules we have to hook into titles.
147. If we use the ML URL Middleware, we namespace those patterns with the title
148. language.
150. All 'normal' patterns from the urlconf get re-written by prefixing them with
151. the title path and then included into the cms url patterns.
152. """
153. from cms.models import Title
154. try:
155. current_site = Site.objects.get_current()
156. except Site.DoesNotExist:
157. current_site = None
158. included = []
160. # we don't have a request here so get_page_queryset() can't be used,
161. # so, if CMS_MODERATOR, use, public() queryset, otherwise
162. # use draft(). This can be done, because url patterns are used just
163. # in frontend
164. is_draft = not settings.CMS_MODERATOR
166. title_qs = Title.objects.filter(page__publisher_is_draft=is_draft, page__site=current_site)
168. if 'cms.middleware.multilingual.MultilingualURLMiddleware' in settings.MIDDLEWARE_CLASSES:
169. use_namespaces = True
170. hooked_applications = {}
171. else:
172. use_namespaces = False
173. hooked_applications = []
175. # Loop over all titles with an application hooked to them
176. for title in title_qs.exclude(application_urls=None).exclude(application_urls='').select_related():
177. path = title.path
178. if use_namespaces:
179. mixid = "%s:%s:%s" % (path + "/", title.application_urls, title.language)
180. else:
181. mixid = "%s:%s" % (path + "/", title.application_urls)
182. if mixid in included:
183. # don't add the same thing twice
184. continue
185. if not settings.APPEND_SLASH:
186. path += '/'
187. if use_namespaces:
188. if title.language not in hooked_applications:
189. hooked_applications[title.language] = []
190. hooked_applications[title.language] += get_patterns_for_title(path, title)
191. else:
192. hooked_applications += get_patterns_for_title(path, title)
193. included.append(mixid)
194. # Build the app patterns to be included in the cms urlconfs
195. app_patterns = []
196. if use_namespaces:
197. for ns, currentpatterns in hooked_applications.items():
198. extra_patterns = patterns('', *currentpatterns)
199. resolver = AppRegexURLResolver(r'', 'app_resolver', namespace=ns)
200. resolver.url_patterns = extra_patterns
201. app_patterns.append(resolver)
202. APP_RESOLVERS.append(resolver)
203. else:
204. extra_patterns = patterns('', *hooked_applications)
205. resolver = AppRegexURLResolver(r'', 'app_resolver')
206. resolver.url_patterns = extra_patterns
207. app_patterns.append(resolver)
208. APP_RESOLVERS.append(resolver)
209. return app_patterns