cms/models/managers.py @@ -3,7 +3,7 @@ Django CMS * Patrick Lauber * Jason Zylks * Simon Meers - +* Peter Cicman Django Page CMS =============== AUTHORS @@ -340,7 +340,8 @@ class PageAdmin(admin.ModelAdmin): self.change_list_template = template_name context = { 'name': _("page"), - 'pages': Page.objects.root().order_by("tree_id"), + + 'pages': Page.objects.all_root().order_by("tree_id"), } context.update(extra_context or {}) change_list = self.changelist_view(request, context) cms/admin/__init__.py @@ -1,32 +1,57 @@ from cms.models import Page from django.conf import settings from django.core.urlresolvers import RegexURLResolver, Resolver404, reverse -from cms.utils import get_language_from_request def applications_page_check(request, current_page=None, path=None): """Tries to found if given path was resolved over application. Applications have higher priority than other cms pages. """ - language = get_language_from_request(request) + if current_page: + return current_page + if path is None: path = request.path.replace(reverse('pages-root'), '', 1) + # check if application resolver can resolve this + try: + page_id = dynamic_app_regex_url_resolver.resolve_page_id(path) + # yes, it is application page + page = Page.objects.get(id=page_id) + + # If current page was matched, then we have some override for content + # from cms, but keep current page. Otherwise return page to which was application assigned. + return page + except Resolver404: + pass + return None + +class PageRegexURLResolver(RegexURLResolver): + page_id = None - page_set = Page.objects.get_pages_with_application(request.site, path, language) - print "ps", page_set - for page in page_set: - urlconf_name = page.get_application_urls(language) - page_path = page.get_path(language) - resolver = RegexURLResolver(r'^' + page_path + "/", urlconf_name) - try: - resolver.resolve(path) - return current_page or page - except Resolver404: - pass - print "> CP: ", current_page - return current_page - + def resolve_page_id(self, path): + """Resolves requested path similar way how resolve does, but instead + of return callback,.. returns page_id to which was application + assigned. + """ + tried = [] + match = self.regex.search(path) + if match: + new_path = path[match.end():] + for pattern in self.urlconf_module.urlpatterns: + try: + sub_match = pattern.resolve(new_path) + except Resolver404, e: + tried.extend([(pattern.regex.pattern + ' ' + t) for t in e.args[0]['tried']]) + else: + if sub_match: + if isinstance(pattern, RegexURLResolver): + return pattern.page_id + else: + return self.page_id + tried.append(pattern.regex.pattern) + raise Resolver404, {'tried': tried, 'path': new_path} -class DynamicAppRegexUrlResolver(RegexURLResolver): + +class DynamicAppRegexURLResolver(PageRegexURLResolver): """Dynamic application url resolver. Used for adding support to standard reverse function used by standard @@ -36,20 +61,46 @@ class DynamicAppRegexUrlResolver(RegexURLResolver): here. """ - # give some name to it - #name = None - def __init__(self): - super(DynamicAppRegexUrlResolver, self).__init__(r'^', "DynamicAppResolver", {}) + super(DynamicAppRegexURLResolver, self).__init__(r'^', "DynamicAppResolver", {}) + self._dynamic_url_conf_module = DynamicURLConfModule() # fake this and provide dynamic instance instead of module @property def urlconf_module(self): - return dynamic_url_conf_module + return self._dynamic_url_conf_module + + def reset_cache(self): + self._dynamic_url_conf_module.reset_cache() + +class ApplicationRegexUrlResolver(PageRegexURLResolver): + def __init__(self, title, default_kwargs={}): + """Creates standard variant of RegexUrlResolver, but adds some usefull + functionality to it. + + Args: + title: Title instance + default_kwargs + """ + + # NOTE: can we use default_kwargs here to pass some aditional data + # to application? - can we deefine some data in admin and pass them here + # will they be be than passed to pattern, and from pattern to view? + # If it will work, will be give us possibility to configure one + # application for multiple hooks. + regex = r'%s' % title.path + if settings.APPEND_SLASH: + regex += r'/' + urlconf_name = title.application_urls -class DynamicUrlConfModule(object): + # assign page_id to resolver, so he knows on which page he was assigned + self.page_id = title.page_id + super(ApplicationRegexUrlResolver, self).__init__(regex, urlconf_name, default_kwargs) + + +class DynamicURLConfModule(object): """Fake urls module class. Creates resolvers for hookable applications on the fly from db. @@ -86,22 +137,10 @@ class DynamicUrlConfModule(object): if mixid in included: # don't add the same thing twice continue - self._urlpatterns.append(self._create_resolver(title)) + self._urlpatterns.append(ApplicationRegexUrlResolver(title)) included.append(mixid) return self._urlpatterns - - def _create_resolver(self, title): - # NOTE: can we use default_kwargs here to pass some aditional data - # to application? - can we deefine some data in admin and pass them here - # will they be be than passed to pattern, and from pattern to view? - # If it will work, will be give us possibility to configure one - # application for multiple hooks. - regex = r'%s' % title.path - if settings.APPEND_SLASH: - regex += r'/' - resolver = RegexURLResolver(regex, title.application_urls) - return resolver - + def reset_cache(self): """Reset urlpatterns cache. Should be called always when there is some application change on any page @@ -110,5 +149,4 @@ class DynamicUrlConfModule(object): # recache patterns with new state fake = self.urlpatterns -dynamic_url_conf_module = DynamicUrlConfModule() - +dynamic_app_regex_url_resolver = DynamicAppRegexURLResolver() \ No newline at end of file cms/appresolver.py @@ -1,19 +1,8 @@ -from cms.utils import get_site_from_request, get_page_from_request +from cms.utils import get_page_from_request from django.utils.cache import patch_vary_headers from django.utils import translation from django.conf import settings import re - -class LazySite(object): - def __get__(self, request, obj_type=None): - if not hasattr(request, '_cached_site'): - request._cached_site = get_site_from_request(request) - return request._cached_site - -class CurrentSiteMiddleware(object): - def process_request(self, request): - request.__class__.site = LazySite() - return None class LazyPage(object): def __get__(self, request, obj_type=None): cms/middleware.py @@ -14,7 +14,7 @@ from cms.urlutils import urljoin import mptt from cms import settings -from cms.managers import PageManager, PagePermissionManager, TitleManager +from cms.models.managers import PageManager, PagePermissionManager, TitleManager from cms.models import signals as cms_signals @@ -194,14 +194,11 @@ class Page(models.Model): load = False if not hasattr(self, "title_cache"): load = True - #print "no attr" elif self.title_cache and self.title_cache.language != language and language and not default_lang: load = True - #print "no lang diff" elif fallback and not self.title_cache: load = True if force_reload: - #print "force" load = True if load: if version_id: @@ -374,34 +371,6 @@ class Title(models.Model): def __unicode__(self): return "%s (%s)" % (self.title, self.slug) - def save(self): - # Build path from parent page's path and slug - if self.has_url_overwrite and self.path: - self.path = self.path.strip(" /") - current_path = None - else: - current_path = self.path - parent_page = self.page.parent - slug = u'%s' % self.slug - if parent_page: - self.path = u'%s/%s' % (Title.objects.get_title(parent_page, language=self.language, language_fallback=True).path, slug) - elif self.page.is_home(): - self.path = '' - else: - self.path = u'%s' % slug - super(Title, self).save() - # Update descendants only if path changed - if current_path != self.path: - descendant_titles = Title.objects.filter( - page__lft__gt=self.page.lft, - page__rght__lt=self.page.rght, - page__tree_id__exact=self.page.tree_id, - language=self.language - ) - for descendant_title in descendant_titles: - descendant_title.path = descendant_title.path.replace(current_path, self.path, 1) - descendant_title.save() - @property def overwrite_url(self): """Return overrwriten url, or None cms/models/__init__.py @@ -1,5 +1,7 @@ from django.dispatch import Signal -"""Signals provided by cms - maybe should be moved under models -""" +# fired after page location is changed - is moved from one node to other page_moved = Signal(providing_args=["instance"]) + +# fired when some of nodes (Title) with applications gets saved +application_post_changed = Signal(providing_args=["instance"]) cms/models/signals.py @@ -1,21 +1,19 @@ from django.db.models import signals -from cms.models import signals as cms_signals, Page -from django.contrib.sites.models import Site, SITE_CACHE +from cms import settings as cms_settings, appresolver +from cms.models import signals as cms_signals, Page, Title from cms.models import CMSPlugin - - - - -"""Signal listeners -""" -def clear_site_cache(sender, instance, **kwargs): - """ - Clears site cache in case a Site instance has been created or an existing - is deleted. That's required to use RequestSite objects properly. - """ - if instance.domain in SITE_CACHE: - del SITE_CACHE[instance.domain] +# Is this still required? +#def clear_site_cache(sender, instance, **kwargs): +# """ +# Clears site cache in case a Site instance has been created or an existing +# is deleted. That's required to use RequestSite objects properly. +# """ +# if instance.domain in SITE_CACHE: +# del SITE_CACHE[instance.domain] +# +#signals.pre_delete.connect(clear_site_cache, sender=Site) +#signals.post_save.connect(clear_site_cache, sender=Site) def update_plugin_positions(**kwargs): @@ -28,13 +26,90 @@ def update_plugin_positions(**kwargs): p.save() last += 1 +signals.post_delete.connect(update_plugin_positions, sender=CMSPlugin) + def update_title_paths(instance, **kwargs): + """Update child pages paths in case when page was moved. + """ for title in instance.title_set.all(): title.save() -signals.pre_delete.connect(clear_site_cache, sender=Site) -signals.post_save.connect(clear_site_cache, sender=Site) -signals.post_delete.connect(update_plugin_positions, sender=CMSPlugin) +cms_signals.page_moved.connect(update_title_paths, sender=Page) + + +def pre_save_title(instance, raw, **kwargs): + """Save old state to instance and setup path + """ + + instance.tmp_path = None + instance.tmp_application_urls = None + + if not instance.id: + tmp_title = Page.objects.get(pk=instance.id) + instance.tmp_path = tmp_title.path + instance.tmp_application_urls = tmp_title.appliction_urls + + # Build path from parent page's path and slug + if instance.has_url_overwrite and instance.path: + instance.path = instance.path.strip(" /") + else: + parent_page = instance.page.parent + slug = u'%s' % instance.slug + if parent_page: + parent_path = Title.objects.get_title(parent_page, language=instance.language, language_fallback=True).path + instance.path = (u'%s/%s' % (parent_path, slug)).lstrip("/") + elif instance.page.is_home(): + instance.path = '' + else: + instance.path = u'%s' % slug + +signals.pre_save.connect(pre_save_title, sender=Title) + + +def post_save_title(instance, raw, created, **kwargs): + # Update descendants only if path changed + application_changed = False + + if instance.path != instance.tmp_path and not hasattr(instance, 'tmp_prevent_descendant_update'): + descendant_titles = Title.objects.filter( + page__lft__gt=instance.page.lft, + page__rght__lt=instance.page.rght, + page__tree_id__exact=instance.page.tree_id, + language=instance.language + ).order_by('page__tree_id', 'page__parent', 'page__lft') + + for descendant_title in descendant_titles: + descendant_title.path = '' # just reset path + descendant_title.tmp_prevent_descendant_update = True + if descendant_title.application_urls: + application_changed = True + descendant_title.save() + + if not hasattr(instance, 'tmp_prevent_descendant_update') and \ + (instance.application_urls != instance.tmp_application_urls or application_changed): + # fire it if we have some application linked to this page or some descendant + cms_signals.application_post_changed.send(sender=Title, instance=instance) + + # remove temporary attributes + del(instance.tmp_path) + del(instance.tmp_application_urls) + + try: + del(instance.tmp_prevent_descendant_update) + except AttributeError: + pass + +signals.post_save.connect(post_save_title, sender=Title) + + +def clear_appresolver_cache(instance, **kwargs): + # reset cached applications - there were a change probably + appresolver.dynamic_app_regex_url_resolver.reset_cache() + + +if cms_settings.CMS_APPLICATIONS_URLS: + # register this signal only if we have some hookable applications + cms_signals.application_post_changed.connect(clear_appresolver_cache, sender=Title) + -cms_signals.page_moved.connect(update_title_paths, sender=Page) \ No newline at end of file cms/signals.py @@ -6,7 +6,7 @@ from cms.models import Page, Title, CMSPlugin from cms.utils import get_language_from_request,\ get_extended_navigation_nodes, find_children, cut_levels, find_selected from django.core.mail import send_mail - +from django.contrib.sites.models import Site register = template.Library() @@ -18,7 +18,7 @@ def show_menu(context, from_level=0, to_level=100, extra_inactive=0, extra_activ render_children: if set to True will render all not direct ascendants too """ request = context['request'] - site = request.site + site = Site.objects.get_current() CMS_CONTENT_CACHE_DURATION = settings.CMS_CONTENT_CACHE_DURATION lang = get_language_from_request(request) current_page = request.current_page @@ -112,7 +112,7 @@ def show_sub_menu(context, levels=100, template="cms/sub_menu.html"): render a nested list of all root's children pages""" request = context['request'] lang = get_language_from_request(request) - site = request.site + site = Site.objects.get_current() children = [] page = request.current_page if page: @@ -175,7 +175,7 @@ show_sub_menu = register.inclusion_tag('cms/dummy.html', def show_admin_menu(context, page, no_children=False, level=None): """Render the admin table of pages""" request = context['request'] - site = request.site + site = Site.objects.get_current() lang = get_language_from_request(request) softroot = context['softroot'] if context.has_key("cl"): @@ -214,7 +214,7 @@ def show_breadcrumb(context, start_level=0, template="cms/breadcrumb.html"): if title.page_id == page.pk: page.title_cache = title else: - site = request.site + site = Site.objects.get_current() ancestors = [] extenders = Page.objects.published().filter(in_navigation=True, sites__domain=site.domain) @@ -278,7 +278,7 @@ def page_id_url(context, reverse_id, lang=None): if settings.DEBUG: raise else: - site = request.site + site = Site.objects.get_current() send_mail(_('Reverse ID not found on %(domain)s') % {'domain':site.domain}, _("A page_url template tag didn't found a page with the reverse_id %(reverse_id)s\nThe url of the page was: http://%(host)s%(path)s")%{'reverse_id':reverse_id, 'host':request.host, 'path':request.path}, settings.DEFAULT_FROM_EMAIL, cms/templatetags/cms_tags.py @@ -12,8 +12,11 @@ if settings.CMS_APPLICATIONS_URLS: """If there are some application urls, add special resolver, so we will have standard reverse support. """ - from cms.appresolver import DynamicAppRegexUrlResolver - urlpatterns = (DynamicAppRegexUrlResolver(), ) + urlpatterns + #from cms.appresolver import DynamicAppRegexURLResolver + #urlpatterns = (DynamicAppRegexURLResolver(), ) + urlpatterns + + from cms.appresolver import dynamic_app_regex_url_resolver + urlpatterns = (dynamic_app_regex_url_resolver, ) + urlpatterns urlpatterns = patterns('', *urlpatterns) \ No newline at end of file cms/urls.py @@ -1,9 +1,6 @@ from django.shortcuts import render_to_response from django.template import RequestContext - from django.http import HttpResponse, HttpResponseRedirect -from django.contrib.sites.models import Site, RequestSite, SITE_CACHE - from cms import settings from cms.models import Page @@ -92,50 +89,6 @@ def has_page_add_permission(request, page=None): return True return False -def get_site_from_request(request, check_subdomain=True): - """ - Returns the ``Site`` which matches the host name retreived from - ``request``. - - If no match is found and ``check_subdomain`` is ``True``, the sites are - searched again for sub-domain matches. - - If still no match, or if more than one ``Site`` matched the host name, a - ``RequestSite`` object is returned. - - The returned ``Site`` or ``RequestSite`` object is cached for the host - name retrieved from ``request``. - """ - host = request.get_host().lower() - if host in SITE_CACHE: - # The host name was found in cache, return it. A cache value - # of None means that a RequestSite should just be used. - return SITE_CACHE[host] or RequestSite(request) - matches = Site.objects.filter(domain__iexact=host) - # We use len rather than count to save a second query if there was only - # one matching Site - count = len(matches) - if not count and check_subdomain: - matches = [] - for site in Site.objects.all(): - if host.endswith(site.domain.lower()): - matches.append(site) - count = len(matches) - if count == 1: - # Return the single matching Site - site = matches[0] - else: - site = None - # Cache the site (caching None means we should use RequestSite). - - # Return site, falling back to just using a RequestSite. - if not site: - if settings.CMS_USE_REQUEST_SITE: - site = RequestSite(request) - else: - site = Site.objects.get_current() - SITE_CACHE[host] = site - return site def get_page_from_request(request): """ @@ -145,22 +98,17 @@ def get_page_from_request(request): return request._current_page_cache else: path = request.path - print "get_page_from_request", path from cms.views import details - kw = {} - # fucking ugly monkey patch :S + # TODO: very ugly - change required! + if path.startswith('/admin/'): kw['page_id']=path.split("/")[0] else: kw['slug']=path.split("/")[-2] resp = details(request, no404=True, only_context=True, **kw) - - - #resp = details(request, path=path.split("/")[0], no404=True, only_context=True) - print "get_page_from_request done" return resp['current_page'] cms/utils.py @@ -1,30 +1,28 @@ from django.http import Http404 from django.shortcuts import get_object_or_404 -from django.contrib.sites.models import SITE_CACHE from django.core.urlresolvers import reverse from cms import settings from cms.models import Page from cms.utils import auto_render, get_template_from_request, get_language_from_request from django.db.models.query_utils import Q from cms.appresolver import applications_page_check +from django.contrib.sites.models import Site - -def _get_current_page(site, path, lang): - """Helper for getting current page from path depending on site and language +def _get_current_page(path, lang): + """Helper for getting current page from path depending on language returns: Page or None """ try: - return Page.objects.published(site).filter( + return Page.objects.published().filter( Q(title_set__path=path[:-1], title_set__language=lang)).distinct().select_related()[0] except IndexError: return None - def details(request, page_id=None, slug=None, template_name=settings.CMS_TEMPLATES[0][0], no404=False): lang = get_language_from_request(request) - site = request.site - pages = Page.objects.root(site).order_by("tree_id") + site = Site.objects.get_current() + pages = Page.objects.root().order_by("tree_id") current_page, response = None, None if pages: if page_id: @@ -34,7 +32,7 @@ def details(request, page_id=None, slug=None, template_name=settings.CMS_TEMPLAT current_page = pages[0] else: path = request.path.replace(reverse('pages-root'), '', 1) - current_page = _get_current_page(site, path, lang) + current_page = _get_current_page(path, lang) if settings.CMS_APPLICATIONS_URLS: # check if it should'nt point to some application, if yes, # change current page if required cms/views.py @@ -73,7 +73,6 @@ MIDDLEWARE_CLASSES = ( 'django.middleware.common.CommonMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.middleware.doc.XViewMiddleware', - 'cms.middleware.CurrentSiteMiddleware', 'cms.middleware.CurrentPageMiddleware', 'cms.middleware.MultilingualURLMiddleware', #'debug_toolbar.middleware.DebugToolbarMiddleware', example/settings.py @@ -163,7 +163,6 @@ class TreeManager(models.Manager): return node def move_node(self, node, target, position='last-child'): - print "> move_node()" """ Moves ``node`` relative to a given ``target`` node as specified by ``position`` (when appropriate), by examining both nodes and mptt/managers.py cms/managers.py 0881951c780ab261772d99ba9771a62b85dfab94 pcicman cip@i7.local http://github.com/digi604/django-cms-2.0/commit/52be9e92ef7404899731fa55ec7d80c4e9ffbae4 52be9e92ef7404899731fa55ec7d80c4e9ffbae4 2009-04-21T00:47:24-07:00 2009-04-20T07:17:12-07:00 Sites (domains) unified with django sites framework. Application hook complete. Signed-off-by: Patrick Lauber <patrick.lauber@divio.ch> f32665ce6726c40afb55c6b5f9ff59084a7cea5a Patrick Lauber patrick.lauber@divio.ch