def current_site_id(): """ Responsible for determining the current ``Site`` instance to use when retrieving data for any ``SiteRelated`` models. If a request is available, and the site can be determined from it, we store the site against the request for subsequent retrievals. Otherwise the order of checks is as follows: - ``site_id`` in session. Used in the admin so that admin users can switch sites and stay on the same domain for the admin. - host for the current request matched to the domain of the site instance. - ``MEZZANINE_SITE_ID`` environment variable, so management commands or anything else outside of a request can specify a site. - ``SITE_ID`` setting. """ request = current_request() site_id = getattr(request, "site_id", None) if request and not site_id: site_id = request.session.get("site_id", None) if not site_id: domain = request.get_host().lower() try: site = Site.objects.get(domain__iexact=domain) except Site.DoesNotExist: pass else: site_id = site.id if request and site_id: request.site_id = site_id if not site_id: site_id = os.environ.get("MEZZANINE_SITE_ID", settings.SITE_ID) return site_id
def current_site_id(): """ Responsible for determining the current ``Site`` instance to use when retrieving data for any ``SiteRelated`` models. If we're inside an override_current_site_id context manager, return the overriding site ID. Otherwise, try to determine the site using the following methods in order: - ``site_id`` in session. Used in the admin so that admin users can switch sites and stay on the same domain for the admin. - The id of the Site object corresponding to the hostname in the current request. This result is cached. - ``MEZZANINE_SITE_ID`` environment variable, so management commands or anything else outside of a request can specify a site. - ``SITE_ID`` setting. If a current request exists and the current site is not overridden, the site ID is stored on the request object to speed up subsequent calls. """ if hasattr(override_current_site_id.thread_local, "site_id"): return override_current_site_id.thread_local.site_id from mezzanine.utils.cache import cache_installed, cache_get, cache_set request = current_request() site_id = getattr(request, "site_id", None) if request and not site_id: site_id = request.session.get("site_id", None) if not site_id: domain = request.get_host().lower() if cache_installed(): # Don't use Mezzanine's cache_key_prefix here, since it # uses this very function we're in right now to create a # per-site cache key. bits = (settings.CACHE_MIDDLEWARE_KEY_PREFIX, domain) cache_key = "%s.site_id.%s" % bits site_id = cache_get(cache_key) if not site_id: try: site = Site.objects.get(domain__iexact=domain) except Site.DoesNotExist: pass else: site_id = site.id if cache_installed(): cache_set(cache_key, site_id) if not site_id: try: cur_language = translation.get_language() site_id = settings.LANGUAGE_SITE_MAP[cur_language] except KeyError: site_id = os.environ.get("MEZZANINE_SITE_ID", settings.SITE_ID) msg = 'Please add language %s to settings.LANGUAGE_SITE_MAP' sys.stdout.write(msg % cur_language) if request and site_id and not getattr(settings, "TESTING", False): request.site_id = site_id return site_id
def render_copyright(self): ''' Render the footer ''' c = RequestContext(current_request()) try: t = Template(self.copyright) except TemplateSyntaxError: return '' return t.render(c)
def test_unicode_slug_parm_to_processor_for(self): """ Test that passing an unicode slug to processor_for works for python 2.x """ from mezzanine.pages.page_processors import processor_for @processor_for(u'test unicode string') def test_page_processor(request, page): return {} page, _ = RichTextPage.objects.get_or_create(title="test page") self.assertEqual(test_page_processor(current_request(), page), {})
def current_site_id(): """ Responsible for determining the current ``Site`` instance to use when retrieving data for any ``SiteRelated`` models. If a request is available, and the site can be determined from it, we store the site against the request for subsequent retrievals. Otherwise the order of checks is as follows: - ``site_id`` in session. Used in the admin so that admin users can switch sites and stay on the same domain for the admin. - host for the current request matched to the domain of the site instance. - ``MEZZANINE_SITE_ID`` environment variable, so management commands or anything else outside of a request can specify a site. - ``SITE_ID`` setting. """ from mezzanine.utils.cache import cache_installed, cache_get, cache_set request = current_request() site_id = getattr(request, "site_id", None) if request and not site_id: site_id = request.session.get("site_id", None) if not site_id: domain = request.get_host().lower() if cache_installed(): # Don't use Mezzanine's cache_key_prefix here, since it # uses this very function we're in right now to create a # per-site cache key. bits = (settings.CACHE_MIDDLEWARE_KEY_PREFIX, domain) cache_key = "%s.site_id.%s" % bits site_id = cache_get(cache_key) if not site_id: try: site = Site.objects.get(domain__iexact=domain) except Site.DoesNotExist: pass else: site_id = site.id if cache_installed(): cache_set(cache_key, site_id) if request and site_id: request.site_id = site_id if not site_id: site_id = os.environ.get("MEZZANINE_SITE_ID", settings.SITE_ID) if request and site_id and not getattr(settings, "TESTING", False): request.site_id = site_id return site_id
def test_page_ascendants(self): """ Test the methods for looking up ascendants efficiently behave as expected. """ # Create related pages. primary, created = RichTextPage.objects.get_or_create(title="Primary") secondary, created = primary.children.get_or_create(title="Secondary") tertiary, created = secondary.children.get_or_create(title="Tertiary") # Force a site ID to avoid the site query when measuring queries. setattr(current_request(), "site_id", settings.SITE_ID) # Test that get_ascendants() returns the right thing. page = Page.objects.get(id=tertiary.id) ascendants = page.get_ascendants() self.assertEqual(ascendants[0].id, secondary.id) self.assertEqual(ascendants[1].id, primary.id) # Test ascendants are returned in order for slug, using # a single DB query. connection.queries = [] pages_for_slug = Page.objects.with_ascendants_for_slug(tertiary.slug) self.assertEqual(len(connection.queries), 1) self.assertEqual(pages_for_slug[0].id, tertiary.id) self.assertEqual(pages_for_slug[1].id, secondary.id) self.assertEqual(pages_for_slug[2].id, primary.id) # Test page.get_ascendants uses the cached attribute, # without any more queries. connection.queries = [] ascendants = pages_for_slug[0].get_ascendants() self.assertEqual(len(connection.queries), 0) self.assertEqual(ascendants[0].id, secondary.id) self.assertEqual(ascendants[1].id, primary.id) # Use a custom slug in the page path, and test that # Page.objects.with_ascendants_for_slug fails, but # correctly falls back to recursive queries. secondary.slug += "custom" secondary.save() pages_for_slug = Page.objects.with_ascendants_for_slug(tertiary.slug) self.assertEqual(len(pages_for_slug[0]._ascendants), 0) connection.queries = [] ascendants = pages_for_slug[0].get_ascendants() self.assertEqual(len(connection.queries), 2) # 2 parent queries self.assertEqual(pages_for_slug[0].id, tertiary.id) self.assertEqual(ascendants[0].id, secondary.id) self.assertEqual(ascendants[1].id, primary.id)
def get_directory(): """ Returns FB's ``DIRECTORY`` setting, appending a directory using the site's ID if ``MEDIA_LIBRARY_PER_SITE`` is ``True``, and also creating the root directory if missing. """ from mezzanine.conf import settings as mezz_settings from mezzanine.utils.sites import current_site_id from mezzanine.core.request import current_request username = current_request().user.get_username() DIRECTORY = getattr(settings, "FILEBROWSER_DIRECTORY", '/' + username) dirname = DIRECTORY if getattr(mezz_settings, "MEDIA_LIBRARY_PER_SITE", False): dirname = os.path.join(dirname, "site-%s" % current_site_id()) fullpath = os.path.join(mezz_settings.MEDIA_ROOT, dirname) if not default_storage.isdir(fullpath): default_storage.makedirs(fullpath) return dirname
def murl(parser, token): bits = token.split_contents() if len(bits) < 2: raise TemplateSyntaxError("'%s' takes at least one argument" " (path to a view)" % bits[0]) viewname_str = bits[1] viewname = parser.compile_filter(viewname_str) args = [] kwargs = {} asvar = None bits = bits[2:] if len(bits) >= 2 and bits[-2] == 'as': asvar = bits[-1] bits = bits[:-2] if len(bits): for bit in bits: match = kwarg_re.match(bit) if not match: raise TemplateSyntaxError("Malformed arguments to url tag") name, value = match.groups() if name: kwargs[name] = parser.compile_filter(value) else: args.append(parser.compile_filter(value)) request = current_request() site_id_val = parser.compile_filter(str(request.site_id)) if hasattr(request,'site_id'): if args is None and kwargs is None: kwargs = {'site_id': site_id_val} elif args is None and kwargs is not None: kwargs['site_id'] = site_id_val elif args is not None and kwargs is None: args = [site_id_val]+args elif len(args) == 0: kwargs['site_id'] = site_id_val elif len(kwargs) == 0: args = [site_id_val]+list(args) else: kwargs['site_id'] = site_id_val return URLNode(viewname, args, kwargs, asvar)
def absolute_urls(html): """ Converts relative URLs into absolute URLs. Used for RSS feeds to provide more complete HTML for item descriptions, but could also be used as a general richtext filter. """ from bs4 import BeautifulSoup from mezzanine.core.request import current_request request = current_request() if request is not None: dom = BeautifulSoup(html, "html.parser") for tag, attr in ABSOLUTE_URL_TAGS.items(): for node in dom.findAll(tag): url = node.get(attr, "") if url: node[attr] = request.build_absolute_uri(url) html = str(dom) return html
def reverse(viewname, urlconf=None, args=None, kwargs=None, prefix=None, current_app=None): """ Proxy for django's reverse to add in request-specific parameters """ request = current_request() if hasattr(request, "site_id"): if args is None and kwargs is None: kwargs = {"site_id": str(request.site_id)} elif args is None and kwargs is not None: kwargs["site_id"] = str(request.site_id) elif args is not None and kwargs is None: args = tuple([str(request.site_id)] + list(args)) elif len(args) == 0: kwargs["site_id"] = str(request.site_id) elif len(kwargs) == 0: args = tuple([str(request.site_id)] + list(args)) else: kwargs["site_id"] = str(request.site_id) return urlresolvers.reverse( viewname, urlconf=urlconf, args=args, kwargs=kwargs, prefix=prefix, current_app=current_app )
def get_absolute_url_with_host(self): """ URL para montar a pre-visualizacao do Evento, para quando ainda estivar com STATUS=DRAFT """ return current_request().build_absolute_uri(self.get_absolute_url())
def _current_request(self): return current_request() or self.NULL_REQUEST
def url(self): if self.content: return self.content return current_request().build_absolute_uri(self.get_absolute_url())
def url(self): # Uncomment for direct to link when clicking in item # if self.link: # return self.link return current_request().build_absolute_uri(self.get_absolute_url())
def url(self): if self.link: return self.link return current_request().build_absolute_uri(self.get_absolute_url())
def __call__(self, *args, **kwarg): self._request = current_request() self._site = Site.objects.get(id=current_site_id()) return super(PostsRSS, self).__call__(*args, **kwarg)
def get_email_form(self): if self.form: return FormForForm(self.form, RequestContext(current_request()), None, None) return None